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 <string.h>
  23 #include <gdk/gdkkeysyms.h>
  24
  25 #include "gtktreeview.h"
  26 #include "gtkrbtree.h"
  27 #include "gtktreednd.h"
  28 #include "gtktreeprivate.h"
  29 #include "gtkcellrenderer.h"
  30 #include "gtkmain.h"
  31 #include "gtkmarshalers.h"
  32 #include "gtkbuildable.h"
  33 #include "gtkbutton.h"
  34 #include "gtkalignment.h"
  35 #include "gtklabel.h"
  36 #include "gtkhbox.h"
  37 #include "gtkvbox.h"
  38 #include "gtkarrow.h"
  39 #include "gtkintl.h"
  40 #include "gtkbindings.h"
  41 #include "gtkcontainer.h"
  42 #include "gtkentry.h"
  43 #include "gtkframe.h"
  44 #include "gtktreemodelsort.h"
  45 #include "gtktooltip.h"
  46 #include "gtkprivate.h"
  47 #include "gtkalias.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_NUM_ROWS_PER_IDLE 500
  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_expose               (GtkWidget        *widget,
 173                                                     GdkEventExpose   *event);
 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                                                               const GdkRectangle *clip_rect);
 329 static void     gtk_tree_view_draw_arrow                     (GtkTreeView        *tree_view,
 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 gboolean gtk_tree_view_discover_dirty_iter            (GtkTreeView        *tree_view,
 349                                                               GtkTreeIter        *iter,
 350                                                               gint                depth,
 351                                                               gint               *height,
 352                                                               GtkRBNode          *node);
 353 static void     gtk_tree_view_discover_dirty                 (GtkTreeView        *tree_view,
 354                                                               GtkRBTree          *tree,
 355                                                               GtkTreeIter        *iter,
 356                                                               gint                depth);
 357 static void     gtk_tree_view_clamp_node_visible             (GtkTreeView        *tree_view,
 358                                                               GtkRBTree          *tree,
 359                                                               GtkRBNode          *node);
 360 static void     gtk_tree_view_clamp_column_visible           (GtkTreeView        *tree_view,
 361                                                               GtkTreeViewColumn  *column,
 362                                                               gboolean            focus_to_cell);
 363 static gboolean gtk_tree_view_maybe_begin_dragging_row       (GtkTreeView        *tree_view,
 364                                                               GdkEventMotion     *event);
 365 static void     gtk_tree_view_focus_to_cursor                (GtkTreeView        *tree_view);
 366 static void     gtk_tree_view_move_cursor_up_down            (GtkTreeView        *tree_view,
 367                                                               gint                count);
 368 static void     gtk_tree_view_move_cursor_page_up_down       (GtkTreeView        *tree_view,
 369                                                               gint                count);
 370 static void     gtk_tree_view_move_cursor_left_right         (GtkTreeView        *tree_view,
 371                                                               gint                count);
 372 static void     gtk_tree_view_move_cursor_start_end          (GtkTreeView        *tree_view,
 373                                                               gint                count);
 374 static gboolean gtk_tree_view_real_collapse_row              (GtkTreeView        *tree_view,
 375                                                               GtkTreePath        *path,
 376                                                               GtkRBTree          *tree,
 377                                                               GtkRBNode          *node,
 378                                                               gboolean            animate);
 379 static gboolean gtk_tree_view_real_expand_row                (GtkTreeView        *tree_view,
 380                                                               GtkTreePath        *path,
 381                                                               GtkRBTree          *tree,
 382                                                               GtkRBNode          *node,
 383                                                               gboolean            open_all,
 384                                                               gboolean            animate);
 385 static void     gtk_tree_view_real_set_cursor                (GtkTreeView        *tree_view,
 386                                                               GtkTreePath        *path,
 387                                                               gboolean            clear_and_select,
 388                                                               gboolean            clamp_node);
 389 static gboolean gtk_tree_view_has_special_cell               (GtkTreeView        *tree_view);
 390 static void     column_sizing_notify                         (GObject            *object,
 391                                                               GParamSpec         *pspec,
 392                                                               gpointer            data);
 393 static gboolean expand_collapse_timeout                      (gpointer            data);
 394 static void     add_expand_collapse_timeout                  (GtkTreeView        *tree_view,
 395                                                               GtkRBTree          *tree,
 396                                                               GtkRBNode          *node,
 397                                                               gboolean            expand);
 398 static void     remove_expand_collapse_timeout               (GtkTreeView        *tree_view);
 399 static void     cancel_arrow_animation                       (GtkTreeView        *tree_view);
 400 static gboolean do_expand_collapse                           (GtkTreeView        *tree_view);
 401 static void     gtk_tree_view_stop_rubber_band               (GtkTreeView        *tree_view);
 402
 403 /* interactive search */
 404 static void     gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view);
 405 static void     gtk_tree_view_search_dialog_hide     (GtkWidget        *search_dialog,
 406                                                          GtkTreeView      *tree_view);
 407 static void     gtk_tree_view_search_position_func      (GtkTreeView      *tree_view,
 408                                                          GtkWidget        *search_dialog,
 409                                                          gpointer          user_data);
 410 static void     gtk_tree_view_search_disable_popdown    (GtkEntry         *entry,
 411                                                          GtkMenu          *menu,
 412                                                          gpointer          data);
 413 static void     gtk_tree_view_search_preedit_changed    (GtkIMContext     *im_context,
 414                                                          GtkTreeView      *tree_view);
 415 static void     gtk_tree_view_search_activate           (GtkEntry         *entry,
 416                                                          GtkTreeView      *tree_view);
 417 static gboolean gtk_tree_view_real_search_enable_popdown(gpointer          data);
 418 static void     gtk_tree_view_search_enable_popdown     (GtkWidget        *widget,
 419                                                          gpointer          data);
 420 static gboolean gtk_tree_view_search_delete_event       (GtkWidget        *widget,
 421                                                          GdkEventAny      *event,
 422                                                          GtkTreeView      *tree_view);
 423 static gboolean gtk_tree_view_search_button_press_event (GtkWidget        *widget,
 424                                                          GdkEventButton   *event,
 425                                                          GtkTreeView      *tree_view);
 426 static gboolean gtk_tree_view_search_scroll_event       (GtkWidget        *entry,
 427                                                          GdkEventScroll   *event,
 428                                                          GtkTreeView      *tree_view);
 429 static gboolean gtk_tree_view_search_key_press_event    (GtkWidget        *entry,
 430                                                          GdkEventKey      *event,
 431                                                          GtkTreeView      *tree_view);
 432 static gboolean gtk_tree_view_search_move               (GtkWidget        *window,
 433                                                          GtkTreeView      *tree_view,
 434                                                          gboolean          up);
 435 static gboolean gtk_tree_view_search_equal_func         (GtkTreeModel     *model,
 436                                                          gint              column,
 437                                                          const gchar      *key,
 438                                                          GtkTreeIter      *iter,
 439                                                          gpointer          search_data);
 440 static gboolean gtk_tree_view_search_iter               (GtkTreeModel     *model,
 441                                                          GtkTreeSelection *selection,
 442                                                          GtkTreeIter      *iter,
 443                                                          const gchar      *text,
 444                                                          gint             *count,
 445                                                          gint              n);
 446 static void     gtk_tree_view_search_init               (GtkWidget        *entry,
 447                                                          GtkTreeView      *tree_view);
 448 static void     gtk_tree_view_put                       (GtkTreeView      *tree_view,
 449                                                          GtkWidget        *child_widget,
 450                                                          gint              x,
 451                                                          gint              y,
 452                                                          gint              width,
 453                                                          gint              height);
 454 static gboolean gtk_tree_view_start_editing             (GtkTreeView      *tree_view,
 455                                                          GtkTreePath      *cursor_path);
 456 static void gtk_tree_view_real_start_editing (GtkTreeView       *tree_view,
 457                                               GtkTreeViewColumn *column,
 458                                               GtkTreePath       *path,
 459                                               GtkCellEditable   *cell_editable,
 460                                               GdkRectangle      *cell_area,
 461                                               GdkEvent          *event,
 462                                               guint              flags);
 463 static void gtk_tree_view_stop_editing                  (GtkTreeView *tree_view,
 464                                                          gboolean     cancel_editing);
 465 static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
 466                                                              gboolean     keybinding);
 467 static gboolean gtk_tree_view_start_interactive_search      (GtkTreeView *tree_view);
 468 static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
 469                                                          GtkTreeViewColumn *column,
 470                                                          gint               drop_position);
 471
 472 /* GtkBuildable */
 473 static void gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
 474                                                GtkBuilder  *builder,
 475                                                GObject     *child,
 476                                                const gchar *type);
 477 static void gtk_tree_view_buildable_init      (GtkBuildableIface *iface);
 478
 479
 480 static gboolean scroll_row_timeout                   (gpointer     data);
 481 static void     add_scroll_timeout                   (GtkTreeView *tree_view);
 482 static void     remove_scroll_timeout                (GtkTreeView *tree_view);
 483
 484 static guint tree_view_signals [LAST_SIGNAL] = { 0 };
 485
 486 \f
 487
 488 /* GType Methods
 489  */
 490
 491 G_DEFINE_TYPE_WITH_CODE (GtkTreeView, gtk_tree_view, GTK_TYPE_CONTAINER,
 492                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 493                                                 gtk_tree_view_buildable_init))
 494
 495 static void
 496 gtk_tree_view_class_init (GtkTreeViewClass *class)
 497 {
 498   GObjectClass *o_class;
 499   GtkObjectClass *object_class;
 500   GtkWidgetClass *widget_class;
 501   GtkContainerClass *container_class;
 502   GtkBindingSet *binding_set;
 503
 504   binding_set = gtk_binding_set_by_class (class);
 505
 506   o_class = (GObjectClass *) class;
 507   object_class = (GtkObjectClass *) class;
 508   widget_class = (GtkWidgetClass *) class;
 509   container_class = (GtkContainerClass *) class;
 510
 511   /* GObject signals */
 512   o_class->set_property = gtk_tree_view_set_property;
 513   o_class->get_property = gtk_tree_view_get_property;
 514   o_class->finalize = gtk_tree_view_finalize;
 515
 516   /* GtkObject signals */
 517   object_class->destroy = gtk_tree_view_destroy;
 518
 519   /* GtkWidget signals */
 520   widget_class->map = gtk_tree_view_map;
 521   widget_class->realize = gtk_tree_view_realize;
 522   widget_class->unrealize = gtk_tree_view_unrealize;
 523   widget_class->size_request = gtk_tree_view_size_request;
 524   widget_class->size_allocate = gtk_tree_view_size_allocate;
 525   widget_class->button_press_event = gtk_tree_view_button_press;
 526   widget_class->button_release_event = gtk_tree_view_button_release;
 527   widget_class->grab_broken_event = gtk_tree_view_grab_broken;
 528   /*widget_class->configure_event = gtk_tree_view_configure;*/
 529   widget_class->motion_notify_event = gtk_tree_view_motion;
 530   widget_class->expose_event = gtk_tree_view_expose;
 531   widget_class->key_press_event = gtk_tree_view_key_press;
 532   widget_class->key_release_event = gtk_tree_view_key_release;
 533   widget_class->enter_notify_event = gtk_tree_view_enter_notify;
 534   widget_class->leave_notify_event = gtk_tree_view_leave_notify;
 535   widget_class->focus_out_event = gtk_tree_view_focus_out;
 536   widget_class->drag_begin = gtk_tree_view_drag_begin;
 537   widget_class->drag_end = gtk_tree_view_drag_end;
 538   widget_class->drag_data_get = gtk_tree_view_drag_data_get;
 539   widget_class->drag_data_delete = gtk_tree_view_drag_data_delete;
 540   widget_class->drag_leave = gtk_tree_view_drag_leave;
 541   widget_class->drag_motion = gtk_tree_view_drag_motion;
 542   widget_class->drag_drop = gtk_tree_view_drag_drop;
 543   widget_class->drag_data_received = gtk_tree_view_drag_data_received;
 544   widget_class->focus = gtk_tree_view_focus;
 545   widget_class->grab_focus = gtk_tree_view_grab_focus;
 546   widget_class->style_set = gtk_tree_view_style_set;
 547   widget_class->grab_notify = gtk_tree_view_grab_notify;
 548   widget_class->state_changed = gtk_tree_view_state_changed;
 549
 550   /* GtkContainer signals */
 551   container_class->remove = gtk_tree_view_remove;
 552   container_class->forall = gtk_tree_view_forall;
 553   container_class->set_focus_child = gtk_tree_view_set_focus_child;
 554
 555   class->set_scroll_adjustments = gtk_tree_view_set_adjustments;
 556   class->move_cursor = gtk_tree_view_real_move_cursor;
 557   class->select_all = gtk_tree_view_real_select_all;
 558   class->unselect_all = gtk_tree_view_real_unselect_all;
 559   class->select_cursor_row = gtk_tree_view_real_select_cursor_row;
 560   class->toggle_cursor_row = gtk_tree_view_real_toggle_cursor_row;
 561   class->expand_collapse_cursor_row = gtk_tree_view_real_expand_collapse_cursor_row;
 562   class->select_cursor_parent = gtk_tree_view_real_select_cursor_parent;
 563   class->start_interactive_search = gtk_tree_view_start_interactive_search;
 564
 565   /* Properties */
 566
 567   g_object_class_install_property (o_class,
 568                                    PROP_MODEL,
 569                                    g_param_spec_object ("model",
 570                                                         P_("TreeView Model"),
 571                                                         P_("The model for the tree view"),
 572                                                         GTK_TYPE_TREE_MODEL,
 573                                                         GTK_PARAM_READWRITE));
 574
 575   g_object_class_install_property (o_class,
 576                                    PROP_HADJUSTMENT,
 577                                    g_param_spec_object ("hadjustment",
 578                                                         P_("Horizontal Adjustment"),
 579                                                         P_("Horizontal Adjustment for the widget"),
 580                                                         GTK_TYPE_ADJUSTMENT,
 581                                                         GTK_PARAM_READWRITE));
 582
 583   g_object_class_install_property (o_class,
 584                                    PROP_VADJUSTMENT,
 585                                    g_param_spec_object ("vadjustment",
 586                                                         P_("Vertical Adjustment"),
 587                                                         P_("Vertical Adjustment for the widget"),
 588                                                         GTK_TYPE_ADJUSTMENT,
 589                                                         GTK_PARAM_READWRITE));
 590
 591   g_object_class_install_property (o_class,
 592                                    PROP_HEADERS_VISIBLE,
 593                                    g_param_spec_boolean ("headers-visible",
 594                                                          P_("Headers Visible"),
 595                                                          P_("Show the column header buttons"),
 596                                                          TRUE,
 597                                                          GTK_PARAM_READWRITE));
 598
 599   g_object_class_install_property (o_class,
 600                                    PROP_HEADERS_CLICKABLE,
 601                                    g_param_spec_boolean ("headers-clickable",
 602                                                          P_("Headers Clickable"),
 603                                                          P_("Column headers respond to click events"),
 604                                                          TRUE,
 605                                                          GTK_PARAM_READWRITE));
 606
 607   g_object_class_install_property (o_class,
 608                                    PROP_EXPANDER_COLUMN,
 609                                    g_param_spec_object ("expander-column",
 610                                                         P_("Expander Column"),
 611                                                         P_("Set the column for the expander column"),
 612                                                         GTK_TYPE_TREE_VIEW_COLUMN,
 613                                                         GTK_PARAM_READWRITE));
 614
 615   g_object_class_install_property (o_class,
 616                                    PROP_REORDERABLE,
 617                                    g_param_spec_boolean ("reorderable",
 618                                                          P_("Reorderable"),
 619                                                          P_("View is reorderable"),
 620                                                          FALSE,
 621                                                          GTK_PARAM_READWRITE));
 622
 623   g_object_class_install_property (o_class,
 624                                    PROP_RULES_HINT,
 625                                    g_param_spec_boolean ("rules-hint",
 626                                                          P_("Rules Hint"),
 627                                                          P_("Set a hint to the theme engine to draw rows in alternating colors"),
 628                                                          FALSE,
 629                                                          GTK_PARAM_READWRITE));
 630
 631     g_object_class_install_property (o_class,
 632                                      PROP_ENABLE_SEARCH,
 633                                      g_param_spec_boolean ("enable-search",
 634                                                            P_("Enable Search"),
 635                                                            P_("View allows user to search through columns interactively"),
 636                                                            TRUE,
 637                                                            GTK_PARAM_READWRITE));
 638
 639     g_object_class_install_property (o_class,
 640                                      PROP_SEARCH_COLUMN,
 641                                      g_param_spec_int ("search-column",
 642                                                        P_("Search Column"),
 643                                                        P_("Model column to search through when searching through code"),
 644                                                        -1,
 645                                                        G_MAXINT,
 646                                                        -1,
 647                                                        GTK_PARAM_READWRITE));
 648
 649     /**
 650      * GtkTreeView:fixed-height-mode:
 651      *
 652      * Setting the ::fixed-height-mode property to %TRUE speeds up
 653      * #GtkTreeView by assuming that all rows have the same height.
 654      * Only enable this option if all rows are the same height.
 655      * Please see gtk_tree_view_set_fixed_height_mode() for more
 656      * information on this option.
 657      *
 658      * Since: 2.4
 659      **/
 660     g_object_class_install_property (o_class,
 661                                      PROP_FIXED_HEIGHT_MODE,
 662                                      g_param_spec_boolean ("fixed-height-mode",
 663                                                            P_("Fixed Height Mode"),
 664                                                            P_("Speeds up GtkTreeView by assuming that all rows have the same height"),
 665                                                            FALSE,
 666                                                            GTK_PARAM_READWRITE));
 667
 668     /**
 669      * GtkTreeView:hover-selection:
 670      *
 671      * Enables of disables the hover selection mode of @tree_view.
 672      * Hover selection makes the selected row follow the pointer.
 673      * Currently, this works only for the selection modes
 674      * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
 675      *
 676      * This mode is primarily intended for treeviews in popups, e.g.
 677      * in #GtkComboBox or #GtkEntryCompletion.
 678      *
 679      * Since: 2.6
 680      */
 681     g_object_class_install_property (o_class,
 682                                      PROP_HOVER_SELECTION,
 683                                      g_param_spec_boolean ("hover-selection",
 684                                                            P_("Hover Selection"),
 685                                                            P_("Whether the selection should follow the pointer"),
 686                                                            FALSE,
 687                                                            GTK_PARAM_READWRITE));
 688
 689     /**
 690      * GtkTreeView:hover-expand:
 691      *
 692      * Enables of disables the hover expansion mode of @tree_view.
 693      * Hover expansion makes rows expand or collapse if the pointer moves
 694      * over them.
 695      *
 696      * This mode is primarily intended for treeviews in popups, e.g.
 697      * in #GtkComboBox or #GtkEntryCompletion.
 698      *
 699      * Since: 2.6
 700      */
 701     g_object_class_install_property (o_class,
 702                                      PROP_HOVER_EXPAND,
 703                                      g_param_spec_boolean ("hover-expand",
 704                                                            P_("Hover Expand"),
 705                                                            P_("Whether rows should be expanded/collapsed when the pointer moves over them"),
 706                                                            FALSE,
 707                                                            GTK_PARAM_READWRITE));
 708
 709     /**
 710      * GtkTreeView:show-expanders:
 711      *
 712      * %TRUE if the view has expanders.
 713      *
 714      * Since: 2.12
 715      */
 716     g_object_class_install_property (o_class,
 717                                      PROP_SHOW_EXPANDERS,
 718                                      g_param_spec_boolean ("show-expanders",
 719                                                            P_("Show Expanders"),
 720                                                            P_("View has expanders"),
 721                                                            TRUE,
 722                                                            GTK_PARAM_READWRITE));
 723
 724     /**
 725      * GtkTreeView:level-indentation:
 726      *
 727      * Extra indentation for each level.
 728      *
 729      * Since: 2.12
 730      */
 731     g_object_class_install_property (o_class,
 732                                      PROP_LEVEL_INDENTATION,
 733                                      g_param_spec_int ("level-indentation",
 734                                                        P_("Level Indentation"),
 735                                                        P_("Extra indentation for each level"),
 736                                                        0,
 737                                                        G_MAXINT,
 738                                                        0,
 739                                                        GTK_PARAM_READWRITE));
 740
 741     g_object_class_install_property (o_class,
 742                                      PROP_RUBBER_BANDING,
 743                                      g_param_spec_boolean ("rubber-banding",
 744                                                            P_("Rubber Banding"),
 745                                                            P_("Whether to enable selection of multiple items by dragging the mouse pointer"),
 746                                                            FALSE,
 747                                                            GTK_PARAM_READWRITE));
 748
 749     g_object_class_install_property (o_class,
 750                                      PROP_ENABLE_GRID_LINES,
 751                                      g_param_spec_enum ("enable-grid-lines",
 752                                                         P_("Enable Grid Lines"),
 753                                                         P_("Whether grid lines should be drawn in the tree view"),
 754                                                         GTK_TYPE_TREE_VIEW_GRID_LINES,
 755                                                         GTK_TREE_VIEW_GRID_LINES_NONE,
 756                                                         GTK_PARAM_READWRITE));
 757
 758     g_object_class_install_property (o_class,
 759                                      PROP_ENABLE_TREE_LINES,
 760                                      g_param_spec_boolean ("enable-tree-lines",
 761                                                            P_("Enable Tree Lines"),
 762                                                            P_("Whether tree lines should be drawn in the tree view"),
 763                                                            FALSE,
 764                                                            GTK_PARAM_READWRITE));
 765
 766     g_object_class_install_property (o_class,
 767                                      PROP_TOOLTIP_COLUMN,
 768                                      g_param_spec_int ("tooltip-column",
 769                                                        P_("Tooltip Column"),
 770                                                        P_("The column in the model containing the tooltip texts for the rows"),
 771                                                        -1,
 772                                                        G_MAXINT,
 773                                                        -1,
 774                                                        GTK_PARAM_READWRITE));
 775
 776   /* Style properties */
 777 #define _TREE_VIEW_EXPANDER_SIZE 12
 778 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
 779 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
 780
 781   gtk_widget_class_install_style_property (widget_class,
 782                                            g_param_spec_int ("expander-size",
 783                                                              P_("Expander Size"),
 784                                                              P_("Size of the expander arrow"),
 785                                                              0,
 786                                                              G_MAXINT,
 787                                                              _TREE_VIEW_EXPANDER_SIZE,
 788                                                              GTK_PARAM_READABLE));
 789
 790   gtk_widget_class_install_style_property (widget_class,
 791                                            g_param_spec_int ("vertical-separator",
 792                                                              P_("Vertical Separator Width"),
 793                                                              P_("Vertical space between cells.  Must be an even number"),
 794                                                              0,
 795                                                              G_MAXINT,
 796                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
 797                                                              GTK_PARAM_READABLE));
 798
 799   gtk_widget_class_install_style_property (widget_class,
 800                                            g_param_spec_int ("horizontal-separator",
 801                                                              P_("Horizontal Separator Width"),
 802                                                              P_("Horizontal space between cells.  Must be an even number"),
 803                                                              0,
 804                                                              G_MAXINT,
 805                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
 806                                                              GTK_PARAM_READABLE));
 807
 808   gtk_widget_class_install_style_property (widget_class,
 809                                            g_param_spec_boolean ("allow-rules",
 810                                                                  P_("Allow Rules"),
 811                                                                  P_("Allow drawing of alternating color rows"),
 812                                                                  TRUE,
 813                                                                  GTK_PARAM_READABLE));
 814
 815   gtk_widget_class_install_style_property (widget_class,
 816                                            g_param_spec_boolean ("indent-expanders",
 817                                                                  P_("Indent Expanders"),
 818                                                                  P_("Make the expanders indented"),
 819                                                                  TRUE,
 820                                                                  GTK_PARAM_READABLE));
 821
 822   gtk_widget_class_install_style_property (widget_class,
 823                                            g_param_spec_boxed ("even-row-color",
 824                                                                P_("Even Row Color"),
 825                                                                P_("Color to use for even rows"),
 826                                                                GDK_TYPE_COLOR,
 827                                                                GTK_PARAM_READABLE));
 828
 829   gtk_widget_class_install_style_property (widget_class,
 830                                            g_param_spec_boxed ("odd-row-color",
 831                                                                P_("Odd Row Color"),
 832                                                                P_("Color to use for odd rows"),
 833                                                                GDK_TYPE_COLOR,
 834                                                                GTK_PARAM_READABLE));
 835
 836   gtk_widget_class_install_style_property (widget_class,
 837                                            g_param_spec_boolean ("row-ending-details",
 838                                                                  P_("Row Ending details"),
 839                                                                  P_("Enable extended row background theming"),
 840                                                                  FALSE,
 841                                                                  GTK_PARAM_READABLE));
 842
 843   gtk_widget_class_install_style_property (widget_class,
 844                                            g_param_spec_int ("grid-line-width",
 845                                                              P_("Grid line width"),
 846                                                              P_("Width, in pixels, of the tree view grid lines"),
 847                                                              0, G_MAXINT, 1,
 848                                                              GTK_PARAM_READABLE));
 849
 850   gtk_widget_class_install_style_property (widget_class,
 851                                            g_param_spec_int ("tree-line-width",
 852                                                              P_("Tree line width"),
 853                                                              P_("Width, in pixels, of the tree view lines"),
 854                                                              0, G_MAXINT, 1,
 855                                                              GTK_PARAM_READABLE));
 856
 857   gtk_widget_class_install_style_property (widget_class,
 858                                            g_param_spec_string ("grid-line-pattern",
 859                                                                 P_("Grid line pattern"),
 860                                                                 P_("Dash pattern used to draw the tree view grid lines"),
 861                                                                 "\1\1",
 862                                                                 GTK_PARAM_READABLE));
 863
 864   gtk_widget_class_install_style_property (widget_class,
 865                                            g_param_spec_string ("tree-line-pattern",
 866                                                                 P_("Tree line pattern"),
 867                                                                 P_("Dash pattern used to draw the tree view lines"),
 868                                                                 "\1\1",
 869                                                                 GTK_PARAM_READABLE));
 870
 871   /* Signals */
 872   /**
 873    * GtkTreeView::set-scroll-adjustments
 874    * @horizontal: the horizontal #GtkAdjustment
 875    * @vertical: the vertical #GtkAdjustment
 876    *
 877    * Set the scroll adjustments for the tree view. Usually scrolled containers
 878    * like #GtkScrolledWindow will emit this signal to connect two instances
 879    * of #GtkScrollbar to the scroll directions of the #GtkTreeView.
 880    */
 881   widget_class->set_scroll_adjustments_signal =
 882     g_signal_new (I_("set-scroll-adjustments"),
 883                   G_TYPE_FROM_CLASS (o_class),
 884                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 885                   G_STRUCT_OFFSET (GtkTreeViewClass, set_scroll_adjustments),
 886                   NULL, NULL,
 887                   _gtk_marshal_VOID__OBJECT_OBJECT,
 888                   G_TYPE_NONE, 2,
 889                   GTK_TYPE_ADJUSTMENT,
 890                   GTK_TYPE_ADJUSTMENT);
 891
 892   /**
 893    * GtkTreeView::row-activated:
 894    * @tree_view: the object on which the signal is emitted
 895    * @path: the #GtkTreePath for the activated row
 896    * @column: the #GtkTreeViewColumn in which the activation occurred
 897    *
 898    * The "row-activated" signal is emitted when the method
 899    * gtk_tree_view_row_activated() is called or the user double clicks
 900    * a treeview row. It is also emitted when a non-editable row is
 901    * selected and one of the keys: Space, Shift+Space, Return or
 902    * Enter is pressed.
 903    *
 904    * For selection handling refer to the <link linkend="TreeWidget">tree
 905    * widget conceptual overview</link> as well as #GtkTreeSelection.
 906    */
 907   tree_view_signals[ROW_ACTIVATED] =
 908     g_signal_new (I_("row-activated"),
 909                   G_TYPE_FROM_CLASS (o_class),
 910                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 911                   G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
 912                   NULL, NULL,
 913                   _gtk_marshal_VOID__BOXED_OBJECT,
 914                   G_TYPE_NONE, 2,
 915                   GTK_TYPE_TREE_PATH,
 916                   GTK_TYPE_TREE_VIEW_COLUMN);
 917
 918   /**
 919    * GtkTreeView::test-expand-row:
 920    * @tree_view: the object on which the signal is emitted
 921    * @iter: the tree iter of the row to expand
 922    * @path: a tree path that points to the row
 923    *
 924    * The given row is about to be expanded (show its children nodes). Use this
 925    * signal if you need to control the expandability of individual rows.
 926    *
 927    * Returns: %FALSE to allow expansion, %TRUE to reject
 928    */
 929   tree_view_signals[TEST_EXPAND_ROW] =
 930     g_signal_new (I_("test-expand-row"),
 931                   G_TYPE_FROM_CLASS (o_class),
 932                   G_SIGNAL_RUN_LAST,
 933                   G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
 934                   _gtk_boolean_handled_accumulator, NULL,
 935                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
 936                   G_TYPE_BOOLEAN, 2,
 937                   GTK_TYPE_TREE_ITER,
 938                   GTK_TYPE_TREE_PATH);
 939
 940   /**
 941    * GtkTreeView::test-collapse-row:
 942    * @tree_view: the object on which the signal is emitted
 943    * @iter: the tree iter of the row to collapse
 944    * @path: a tree path that points to the row
 945    *
 946    * The given row is about to be collapsed (hide its children nodes). Use this
 947    * signal if you need to control the collapsibility of individual rows.
 948    *
 949    * Returns: %FALSE to allow collapsing, %TRUE to reject
 950    */
 951   tree_view_signals[TEST_COLLAPSE_ROW] =
 952     g_signal_new (I_("test-collapse-row"),
 953                   G_TYPE_FROM_CLASS (o_class),
 954                   G_SIGNAL_RUN_LAST,
 955                   G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
 956                   _gtk_boolean_handled_accumulator, NULL,
 957                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
 958                   G_TYPE_BOOLEAN, 2,
 959                   GTK_TYPE_TREE_ITER,
 960                   GTK_TYPE_TREE_PATH);
 961
 962   /**
 963    * GtkTreeView::row-expanded:
 964    * @tree_view: the object on which the signal is emitted
 965    * @iter: the tree iter of the expanded row
 966    * @path: a tree path that points to the row
 967    *
 968    * The given row has been expanded (child nodes are shown).
 969    */
 970   tree_view_signals[ROW_EXPANDED] =
 971     g_signal_new (I_("row-expanded"),
 972                   G_TYPE_FROM_CLASS (o_class),
 973                   G_SIGNAL_RUN_LAST,
 974                   G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
 975                   NULL, NULL,
 976                   _gtk_marshal_VOID__BOXED_BOXED,
 977                   G_TYPE_NONE, 2,
 978                   GTK_TYPE_TREE_ITER,
 979                   GTK_TYPE_TREE_PATH);
 980
 981   /**
 982    * GtkTreeView::row-collapsed:
 983    * @tree_view: the object on which the signal is emitted
 984    * @iter: the tree iter of the collapsed row
 985    * @path: a tree path that points to the row
 986    *
 987    * The given row has been collapsed (child nodes are hidden).
 988    */
 989   tree_view_signals[ROW_COLLAPSED] =
 990     g_signal_new (I_("row-collapsed"),
 991                   G_TYPE_FROM_CLASS (o_class),
 992                   G_SIGNAL_RUN_LAST,
 993                   G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
 994                   NULL, NULL,
 995                   _gtk_marshal_VOID__BOXED_BOXED,
 996                   G_TYPE_NONE, 2,
 997                   GTK_TYPE_TREE_ITER,
 998                   GTK_TYPE_TREE_PATH);
 999
1000   /**
1001    * GtkTreeView::columns-changed:
1002    * @tree_view: the object on which the signal is emitted
1003    *
1004    * The number of columns of the treeview has changed.
1005    */
1006   tree_view_signals[COLUMNS_CHANGED] =
1007     g_signal_new (I_("columns-changed"),
1008                   G_TYPE_FROM_CLASS (o_class),
1009                   G_SIGNAL_RUN_LAST,
1010                   G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
1011                   NULL, NULL,
1012                   _gtk_marshal_VOID__VOID,
1013                   G_TYPE_NONE, 0);
1014
1015   /**
1016    * GtkTreeView::cursor-changed:
1017    * @tree_view: the object on which the signal is emitted
1018    *
1019    * The position of the cursor (focused cell) has changed.
1020    */
1021   tree_view_signals[CURSOR_CHANGED] =
1022     g_signal_new (I_("cursor-changed"),
1023                   G_TYPE_FROM_CLASS (o_class),
1024                   G_SIGNAL_RUN_LAST,
1025                   G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
1026                   NULL, NULL,
1027                   _gtk_marshal_VOID__VOID,
1028                   G_TYPE_NONE, 0);
1029
1030   tree_view_signals[MOVE_CURSOR] =
1031     g_signal_new (I_("move-cursor"),
1032                   G_TYPE_FROM_CLASS (object_class),
1033                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1034                   G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
1035                   NULL, NULL,
1036                   _gtk_marshal_BOOLEAN__ENUM_INT,
1037                   G_TYPE_BOOLEAN, 2,
1038                   GTK_TYPE_MOVEMENT_STEP,
1039                   G_TYPE_INT);
1040
1041   tree_view_signals[SELECT_ALL] =
1042     g_signal_new (I_("select-all"),
1043                   G_TYPE_FROM_CLASS (object_class),
1044                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1045                   G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
1046                   NULL, NULL,
1047                   _gtk_marshal_BOOLEAN__VOID,
1048                   G_TYPE_BOOLEAN, 0);
1049
1050   tree_view_signals[UNSELECT_ALL] =
1051     g_signal_new (I_("unselect-all"),
1052                   G_TYPE_FROM_CLASS (object_class),
1053                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1054                   G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
1055                   NULL, NULL,
1056                   _gtk_marshal_BOOLEAN__VOID,
1057                   G_TYPE_BOOLEAN, 0);
1058
1059   tree_view_signals[SELECT_CURSOR_ROW] =
1060     g_signal_new (I_("select-cursor-row"),
1061                   G_TYPE_FROM_CLASS (object_class),
1062                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1063                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
1064                   NULL, NULL,
1065                   _gtk_marshal_BOOLEAN__BOOLEAN,
1066                   G_TYPE_BOOLEAN, 1,
1067                   G_TYPE_BOOLEAN);
1068
1069   tree_view_signals[TOGGLE_CURSOR_ROW] =
1070     g_signal_new (I_("toggle-cursor-row"),
1071                   G_TYPE_FROM_CLASS (object_class),
1072                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1073                   G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
1074                   NULL, NULL,
1075                   _gtk_marshal_BOOLEAN__VOID,
1076                   G_TYPE_BOOLEAN, 0);
1077
1078   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
1079     g_signal_new (I_("expand-collapse-cursor-row"),
1080                   G_TYPE_FROM_CLASS (object_class),
1081                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1082                   G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
1083                   NULL, NULL,
1084                   _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
1085                   G_TYPE_BOOLEAN, 3,
1086                   G_TYPE_BOOLEAN,
1087                   G_TYPE_BOOLEAN,
1088                   G_TYPE_BOOLEAN);
1089
1090   tree_view_signals[SELECT_CURSOR_PARENT] =
1091     g_signal_new (I_("select-cursor-parent"),
1092                   G_TYPE_FROM_CLASS (object_class),
1093                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1094                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
1095                   NULL, NULL,
1096                   _gtk_marshal_BOOLEAN__VOID,
1097                   G_TYPE_BOOLEAN, 0);
1098
1099   tree_view_signals[START_INTERACTIVE_SEARCH] =
1100     g_signal_new (I_("start-interactive-search"),
1101                   G_TYPE_FROM_CLASS (object_class),
1102                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1103                   G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
1104                   NULL, NULL,
1105                   _gtk_marshal_BOOLEAN__VOID,
1106                   G_TYPE_BOOLEAN, 0);
1107
1108   /* Key bindings */
1109   gtk_tree_view_add_move_binding (binding_set, GDK_Up, 0, TRUE,
1110                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1111   gtk_tree_view_add_move_binding (binding_set, GDK_KP_Up, 0, TRUE,
1112                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1113
1114   gtk_tree_view_add_move_binding (binding_set, GDK_Down, 0, TRUE,
1115                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1116   gtk_tree_view_add_move_binding (binding_set, GDK_KP_Down, 0, TRUE,
1117                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1118
1119   gtk_tree_view_add_move_binding (binding_set, GDK_p, GDK_CONTROL_MASK, FALSE,
1120                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1121
1122   gtk_tree_view_add_move_binding (binding_set, GDK_n, GDK_CONTROL_MASK, FALSE,
1123                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1124
1125   gtk_tree_view_add_move_binding (binding_set, GDK_Home, 0, TRUE,
1126                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1127   gtk_tree_view_add_move_binding (binding_set, GDK_KP_Home, 0, TRUE,
1128                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1129
1130   gtk_tree_view_add_move_binding (binding_set, GDK_End, 0, TRUE,
1131                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1132   gtk_tree_view_add_move_binding (binding_set, GDK_KP_End, 0, TRUE,
1133                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1134
1135   gtk_tree_view_add_move_binding (binding_set, GDK_Page_Up, 0, TRUE,
1136                                   GTK_MOVEMENT_PAGES, -1);
1137   gtk_tree_view_add_move_binding (binding_set, GDK_KP_Page_Up, 0, TRUE,
1138                                   GTK_MOVEMENT_PAGES, -1);
1139
1140   gtk_tree_view_add_move_binding (binding_set, GDK_Page_Down, 0, TRUE,
1141                                   GTK_MOVEMENT_PAGES, 1);
1142   gtk_tree_view_add_move_binding (binding_set, GDK_KP_Page_Down, 0, TRUE,
1143                                   GTK_MOVEMENT_PAGES, 1);
1144
1145
1146   gtk_binding_entry_add_signal (binding_set, GDK_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_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_KP_Right, 0, "move-cursor", 2,
1155                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1156                                 G_TYPE_INT, 1);
1157
1158   gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, 0, "move-cursor", 2,
1159                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1160                                 G_TYPE_INT, -1);
1161
1162   gtk_binding_entry_add_signal (binding_set, GDK_Right, GDK_CONTROL_MASK,
1163                                 "move-cursor", 2,
1164                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1165                                 G_TYPE_INT, 1);
1166
1167   gtk_binding_entry_add_signal (binding_set, GDK_Left, GDK_CONTROL_MASK,
1168                                 "move-cursor", 2,
1169                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1170                                 G_TYPE_INT, -1);
1171
1172   gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, GDK_CONTROL_MASK,
1173                                 "move-cursor", 2,
1174                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1175                                 G_TYPE_INT, 1);
1176
1177   gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, GDK_CONTROL_MASK,
1178                                 "move-cursor", 2,
1179                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1180                                 G_TYPE_INT, -1);
1181
1182   gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1183   gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1184
1185   gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK, "select-all", 0);
1186   gtk_binding_entry_add_signal (binding_set, GDK_slash, GDK_CONTROL_MASK, "select-all", 0);
1187
1188   gtk_binding_entry_add_signal (binding_set, GDK_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1189   gtk_binding_entry_add_signal (binding_set, GDK_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1190
1191   gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1192                                 G_TYPE_BOOLEAN, TRUE);
1193   gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1194                                 G_TYPE_BOOLEAN, TRUE);
1195
1196   gtk_binding_entry_add_signal (binding_set, GDK_space, 0, "select-cursor-row", 1,
1197                                 G_TYPE_BOOLEAN, TRUE);
1198   gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, 0, "select-cursor-row", 1,
1199                                 G_TYPE_BOOLEAN, TRUE);
1200   gtk_binding_entry_add_signal (binding_set, GDK_Return, 0, "select-cursor-row", 1,
1201                                 G_TYPE_BOOLEAN, TRUE);
1202   gtk_binding_entry_add_signal (binding_set, GDK_ISO_Enter, 0, "select-cursor-row", 1,
1203                                 G_TYPE_BOOLEAN, TRUE);
1204   gtk_binding_entry_add_signal (binding_set, GDK_KP_Enter, 0, "select-cursor-row", 1,
1205                                 G_TYPE_BOOLEAN, TRUE);
1206
1207   /* expand and collapse rows */
1208   gtk_binding_entry_add_signal (binding_set, GDK_plus, 0, "expand-collapse-cursor-row", 3,
1209                                 G_TYPE_BOOLEAN, TRUE,
1210                                 G_TYPE_BOOLEAN, TRUE,
1211                                 G_TYPE_BOOLEAN, FALSE);
1212
1213   gtk_binding_entry_add_signal (binding_set, GDK_asterisk, 0,
1214                                 "expand-collapse-cursor-row", 3,
1215                                 G_TYPE_BOOLEAN, TRUE,
1216                                 G_TYPE_BOOLEAN, TRUE,
1217                                 G_TYPE_BOOLEAN, TRUE);
1218   gtk_binding_entry_add_signal (binding_set, GDK_KP_Multiply, 0,
1219                                 "expand-collapse-cursor-row", 3,
1220                                 G_TYPE_BOOLEAN, TRUE,
1221                                 G_TYPE_BOOLEAN, TRUE,
1222                                 G_TYPE_BOOLEAN, TRUE);
1223
1224   gtk_binding_entry_add_signal (binding_set, GDK_slash, 0,
1225                                 "expand-collapse-cursor-row", 3,
1226                                 G_TYPE_BOOLEAN, TRUE,
1227                                 G_TYPE_BOOLEAN, FALSE,
1228                                 G_TYPE_BOOLEAN, FALSE);
1229   gtk_binding_entry_add_signal (binding_set, GDK_KP_Divide, 0,
1230                                 "expand-collapse-cursor-row", 3,
1231                                 G_TYPE_BOOLEAN, TRUE,
1232                                 G_TYPE_BOOLEAN, FALSE,
1233                                 G_TYPE_BOOLEAN, FALSE);
1234
1235   /* Not doable on US keyboards */
1236   gtk_binding_entry_add_signal (binding_set, GDK_plus, 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_KP_Add, 0, "expand-collapse-cursor-row", 3,
1241                                 G_TYPE_BOOLEAN, TRUE,
1242                                 G_TYPE_BOOLEAN, TRUE,
1243                                 G_TYPE_BOOLEAN, FALSE);
1244   gtk_binding_entry_add_signal (binding_set, GDK_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1245                                 G_TYPE_BOOLEAN, TRUE,
1246                                 G_TYPE_BOOLEAN, TRUE,
1247                                 G_TYPE_BOOLEAN, TRUE);
1248   gtk_binding_entry_add_signal (binding_set, GDK_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1249                                 G_TYPE_BOOLEAN, TRUE,
1250                                 G_TYPE_BOOLEAN, TRUE,
1251                                 G_TYPE_BOOLEAN, TRUE);
1252   gtk_binding_entry_add_signal (binding_set, GDK_Right, GDK_SHIFT_MASK,
1253                                 "expand-collapse-cursor-row", 3,
1254                                 G_TYPE_BOOLEAN, FALSE,
1255                                 G_TYPE_BOOLEAN, TRUE,
1256                                 G_TYPE_BOOLEAN, TRUE);
1257   gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, GDK_SHIFT_MASK,
1258                                 "expand-collapse-cursor-row", 3,
1259                                 G_TYPE_BOOLEAN, FALSE,
1260                                 G_TYPE_BOOLEAN, TRUE,
1261                                 G_TYPE_BOOLEAN, TRUE);
1262   gtk_binding_entry_add_signal (binding_set, GDK_Right,
1263                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1264                                 "expand-collapse-cursor-row", 3,
1265                                 G_TYPE_BOOLEAN, FALSE,
1266                                 G_TYPE_BOOLEAN, TRUE,
1267                                 G_TYPE_BOOLEAN, TRUE);
1268   gtk_binding_entry_add_signal (binding_set, GDK_KP_Right,
1269                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1270                                 "expand-collapse-cursor-row", 3,
1271                                 G_TYPE_BOOLEAN, FALSE,
1272                                 G_TYPE_BOOLEAN, TRUE,
1273                                 G_TYPE_BOOLEAN, TRUE);
1274
1275   gtk_binding_entry_add_signal (binding_set, GDK_minus, 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_minus, 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_KP_Subtract, 0, "expand-collapse-cursor-row", 3,
1284                                 G_TYPE_BOOLEAN, TRUE,
1285                                 G_TYPE_BOOLEAN, FALSE,
1286                                 G_TYPE_BOOLEAN, FALSE);
1287   gtk_binding_entry_add_signal (binding_set, GDK_KP_Subtract, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1288                                 G_TYPE_BOOLEAN, TRUE,
1289                                 G_TYPE_BOOLEAN, FALSE,
1290                                 G_TYPE_BOOLEAN, TRUE);
1291   gtk_binding_entry_add_signal (binding_set, GDK_Left, GDK_SHIFT_MASK,
1292                                 "expand-collapse-cursor-row", 3,
1293                                 G_TYPE_BOOLEAN, FALSE,
1294                                 G_TYPE_BOOLEAN, FALSE,
1295                                 G_TYPE_BOOLEAN, TRUE);
1296   gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, GDK_SHIFT_MASK,
1297                                 "expand-collapse-cursor-row", 3,
1298                                 G_TYPE_BOOLEAN, FALSE,
1299                                 G_TYPE_BOOLEAN, FALSE,
1300                                 G_TYPE_BOOLEAN, TRUE);
1301   gtk_binding_entry_add_signal (binding_set, GDK_Left,
1302                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1303                                 "expand-collapse-cursor-row", 3,
1304                                 G_TYPE_BOOLEAN, FALSE,
1305                                 G_TYPE_BOOLEAN, FALSE,
1306                                 G_TYPE_BOOLEAN, TRUE);
1307   gtk_binding_entry_add_signal (binding_set, GDK_KP_Left,
1308                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1309                                 "expand-collapse-cursor-row", 3,
1310                                 G_TYPE_BOOLEAN, FALSE,
1311                                 G_TYPE_BOOLEAN, FALSE,
1312                                 G_TYPE_BOOLEAN, TRUE);
1313
1314   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0, "select-cursor-parent", 0);
1315   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1316
1317   gtk_binding_entry_add_signal (binding_set, GDK_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1318
1319   gtk_binding_entry_add_signal (binding_set, GDK_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1320
1321   g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
1322 }
1323
1324 static void
1325 gtk_tree_view_buildable_init (GtkBuildableIface *iface)
1326 {
1327   iface->add_child = gtk_tree_view_buildable_add_child;
1328 }
1329
1330 static void
1331 gtk_tree_view_init (GtkTreeView *tree_view)
1332 {
1333   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
1334
1335   GTK_WIDGET_SET_FLAGS (tree_view, GTK_CAN_FOCUS);
1336
1337   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1338
1339   tree_view->priv->flags =  GTK_TREE_VIEW_SHOW_EXPANDERS
1340                             | GTK_TREE_VIEW_DRAW_KEYFOCUS
1341                             | GTK_TREE_VIEW_HEADERS_VISIBLE;
1342
1343   /* We need some padding */
1344   tree_view->priv->dy = 0;
1345   tree_view->priv->cursor_offset = 0;
1346   tree_view->priv->n_columns = 0;
1347   tree_view->priv->header_height = 1;
1348   tree_view->priv->x_drag = 0;
1349   tree_view->priv->drag_pos = -1;
1350   tree_view->priv->header_has_focus = FALSE;
1351   tree_view->priv->pressed_button = -1;
1352   tree_view->priv->press_start_x = -1;
1353   tree_view->priv->press_start_y = -1;
1354   tree_view->priv->reorderable = FALSE;
1355   tree_view->priv->presize_handler_timer = 0;
1356   tree_view->priv->scroll_sync_timer = 0;
1357   tree_view->priv->fixed_height = -1;
1358   tree_view->priv->fixed_height_mode = FALSE;
1359   tree_view->priv->fixed_height_check = 0;
1360   gtk_tree_view_set_adjustments (tree_view, NULL, NULL);
1361   tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
1362   tree_view->priv->enable_search = TRUE;
1363   tree_view->priv->search_column = -1;
1364   tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
1365   tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
1366   tree_view->priv->search_custom_entry_set = FALSE;
1367   tree_view->priv->typeselect_flush_timeout = 0;
1368   tree_view->priv->init_hadjust_value = TRUE;
1369   tree_view->priv->width = 0;
1370
1371   tree_view->priv->hover_selection = FALSE;
1372   tree_view->priv->hover_expand = FALSE;
1373
1374   tree_view->priv->level_indentation = 0;
1375
1376   tree_view->priv->rubber_banding_enable = FALSE;
1377
1378   tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
1379   tree_view->priv->tree_lines_enabled = FALSE;
1380
1381   tree_view->priv->tooltip_column = -1;
1382
1383   tree_view->priv->post_validation_flag = FALSE;
1384 }
1385
1386 \f
1387
1388 /* GObject Methods
1389  */
1390
1391 static void
1392 gtk_tree_view_set_property (GObject         *object,
1393                             guint            prop_id,
1394                             const GValue    *value,
1395                             GParamSpec      *pspec)
1396 {
1397   GtkTreeView *tree_view;
1398
1399   tree_view = GTK_TREE_VIEW (object);
1400
1401   switch (prop_id)
1402     {
1403     case PROP_MODEL:
1404       gtk_tree_view_set_model (tree_view, g_value_get_object (value));
1405       break;
1406     case PROP_HADJUSTMENT:
1407       gtk_tree_view_set_hadjustment (tree_view, g_value_get_object (value));
1408       break;
1409     case PROP_VADJUSTMENT:
1410       gtk_tree_view_set_vadjustment (tree_view, g_value_get_object (value));
1411       break;
1412     case PROP_HEADERS_VISIBLE:
1413       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1414       break;
1415     case PROP_HEADERS_CLICKABLE:
1416       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1417       break;
1418     case PROP_EXPANDER_COLUMN:
1419       gtk_tree_view_set_expander_column (tree_view, g_value_get_object (value));
1420       break;
1421     case PROP_REORDERABLE:
1422       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
1423       break;
1424     case PROP_RULES_HINT:
1425       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1426       break;
1427     case PROP_ENABLE_SEARCH:
1428       gtk_tree_view_set_enable_search (tree_view, g_value_get_boolean (value));
1429       break;
1430     case PROP_SEARCH_COLUMN:
1431       gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
1432       break;
1433     case PROP_FIXED_HEIGHT_MODE:
1434       gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
1435       break;
1436     case PROP_HOVER_SELECTION:
1437       tree_view->priv->hover_selection = g_value_get_boolean (value);
1438       break;
1439     case PROP_HOVER_EXPAND:
1440       tree_view->priv->hover_expand = g_value_get_boolean (value);
1441       break;
1442     case PROP_SHOW_EXPANDERS:
1443       gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
1444       break;
1445     case PROP_LEVEL_INDENTATION:
1446       tree_view->priv->level_indentation = g_value_get_int (value);
1447       break;
1448     case PROP_RUBBER_BANDING:
1449       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1450       break;
1451     case PROP_ENABLE_GRID_LINES:
1452       gtk_tree_view_set_grid_lines (tree_view, g_value_get_enum (value));
1453       break;
1454     case PROP_ENABLE_TREE_LINES:
1455       gtk_tree_view_set_enable_tree_lines (tree_view, g_value_get_boolean (value));
1456       break;
1457     case PROP_TOOLTIP_COLUMN:
1458       gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
1459       break;
1460     default:
1461       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1462       break;
1463     }
1464 }
1465
1466 static void
1467 gtk_tree_view_get_property (GObject    *object,
1468                             guint       prop_id,
1469                             GValue     *value,
1470                             GParamSpec *pspec)
1471 {
1472   GtkTreeView *tree_view;
1473
1474   tree_view = GTK_TREE_VIEW (object);
1475
1476   switch (prop_id)
1477     {
1478     case PROP_MODEL:
1479       g_value_set_object (value, tree_view->priv->model);
1480       break;
1481     case PROP_HADJUSTMENT:
1482       g_value_set_object (value, tree_view->priv->hadjustment);
1483       break;
1484     case PROP_VADJUSTMENT:
1485       g_value_set_object (value, tree_view->priv->vadjustment);
1486       break;
1487     case PROP_HEADERS_VISIBLE:
1488       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
1489       break;
1490     case PROP_HEADERS_CLICKABLE:
1491       g_value_set_boolean (value, gtk_tree_view_get_headers_clickable (tree_view));
1492       break;
1493     case PROP_EXPANDER_COLUMN:
1494       g_value_set_object (value, tree_view->priv->expander_column);
1495       break;
1496     case PROP_REORDERABLE:
1497       g_value_set_boolean (value, tree_view->priv->reorderable);
1498       break;
1499     case PROP_RULES_HINT:
1500       g_value_set_boolean (value, tree_view->priv->has_rules);
1501       break;
1502     case PROP_ENABLE_SEARCH:
1503       g_value_set_boolean (value, tree_view->priv->enable_search);
1504       break;
1505     case PROP_SEARCH_COLUMN:
1506       g_value_set_int (value, tree_view->priv->search_column);
1507       break;
1508     case PROP_FIXED_HEIGHT_MODE:
1509       g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
1510       break;
1511     case PROP_HOVER_SELECTION:
1512       g_value_set_boolean (value, tree_view->priv->hover_selection);
1513       break;
1514     case PROP_HOVER_EXPAND:
1515       g_value_set_boolean (value, tree_view->priv->hover_expand);
1516       break;
1517     case PROP_SHOW_EXPANDERS:
1518       g_value_set_boolean (value, GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS));
1519       break;
1520     case PROP_LEVEL_INDENTATION:
1521       g_value_set_int (value, tree_view->priv->level_indentation);
1522       break;
1523     case PROP_RUBBER_BANDING:
1524       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1525       break;
1526     case PROP_ENABLE_GRID_LINES:
1527       g_value_set_enum (value, tree_view->priv->grid_lines);
1528       break;
1529     case PROP_ENABLE_TREE_LINES:
1530       g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
1531       break;
1532     case PROP_TOOLTIP_COLUMN:
1533       g_value_set_int (value, tree_view->priv->tooltip_column);
1534       break;
1535     default:
1536       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1537       break;
1538     }
1539 }
1540
1541 static void
1542 gtk_tree_view_finalize (GObject *object)
1543 {
1544   G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
1545 }
1546
1547 \f
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 /* GtkObject Methods
1559  */
1560
1561 static void
1562 gtk_tree_view_free_rbtree (GtkTreeView *tree_view)
1563 {
1564   _gtk_rbtree_free (tree_view->priv->tree);
1565
1566   tree_view->priv->tree = NULL;
1567   tree_view->priv->button_pressed_node = NULL;
1568   tree_view->priv->button_pressed_tree = NULL;
1569   tree_view->priv->prelight_tree = NULL;
1570   tree_view->priv->prelight_node = NULL;
1571   tree_view->priv->expanded_collapsed_node = NULL;
1572   tree_view->priv->expanded_collapsed_tree = NULL;
1573 }
1574
1575 static void
1576 gtk_tree_view_destroy (GtkObject *object)
1577 {
1578   GtkTreeView *tree_view = GTK_TREE_VIEW (object);
1579   GList *list;
1580
1581   gtk_tree_view_stop_editing (tree_view, TRUE);
1582
1583   if (tree_view->priv->columns != NULL)
1584     {
1585       list = tree_view->priv->columns;
1586       while (list)
1587         {
1588           GtkTreeViewColumn *column;
1589           column = GTK_TREE_VIEW_COLUMN (list->data);
1590           list = list->next;
1591           gtk_tree_view_remove_column (tree_view, column);
1592         }
1593       tree_view->priv->columns = NULL;
1594     }
1595
1596   if (tree_view->priv->tree != NULL)
1597     {
1598       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
1599
1600       gtk_tree_view_free_rbtree (tree_view);
1601     }
1602
1603   if (tree_view->priv->selection != NULL)
1604     {
1605       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
1606       g_object_unref (tree_view->priv->selection);
1607       tree_view->priv->selection = NULL;
1608     }
1609
1610   if (tree_view->priv->scroll_to_path != NULL)
1611     {
1612       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
1613       tree_view->priv->scroll_to_path = NULL;
1614     }
1615
1616   if (tree_view->priv->drag_dest_row != NULL)
1617     {
1618       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
1619       tree_view->priv->drag_dest_row = NULL;
1620     }
1621
1622   if (tree_view->priv->last_button_press != NULL)
1623     {
1624       gtk_tree_row_reference_free (tree_view->priv->last_button_press);
1625       tree_view->priv->last_button_press = NULL;
1626     }
1627
1628   if (tree_view->priv->last_button_press_2 != NULL)
1629     {
1630       gtk_tree_row_reference_free (tree_view->priv->last_button_press_2);
1631       tree_view->priv->last_button_press_2 = NULL;
1632     }
1633
1634   if (tree_view->priv->top_row != NULL)
1635     {
1636       gtk_tree_row_reference_free (tree_view->priv->top_row);
1637       tree_view->priv->top_row = NULL;
1638     }
1639
1640   if (tree_view->priv->column_drop_func_data &&
1641       tree_view->priv->column_drop_func_data_destroy)
1642     {
1643       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
1644       tree_view->priv->column_drop_func_data = NULL;
1645     }
1646
1647   if (tree_view->priv->destroy_count_destroy &&
1648       tree_view->priv->destroy_count_data)
1649     {
1650       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
1651       tree_view->priv->destroy_count_data = NULL;
1652     }
1653
1654   gtk_tree_row_reference_free (tree_view->priv->cursor);
1655   tree_view->priv->cursor = NULL;
1656
1657   gtk_tree_row_reference_free (tree_view->priv->anchor);
1658   tree_view->priv->anchor = NULL;
1659
1660   /* destroy interactive search dialog */
1661   if (tree_view->priv->search_window)
1662     {
1663       gtk_widget_destroy (tree_view->priv->search_window);
1664       tree_view->priv->search_window = NULL;
1665       tree_view->priv->search_entry = NULL;
1666       if (tree_view->priv->typeselect_flush_timeout)
1667         {
1668           g_source_remove (tree_view->priv->typeselect_flush_timeout);
1669           tree_view->priv->typeselect_flush_timeout = 0;
1670         }
1671     }
1672
1673   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
1674     {
1675       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
1676       tree_view->priv->search_user_data = NULL;
1677     }
1678
1679   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
1680     {
1681       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
1682       tree_view->priv->search_position_user_data = NULL;
1683     }
1684
1685   if (tree_view->priv->row_separator_destroy && tree_view->priv->row_separator_data)
1686     {
1687       tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
1688       tree_view->priv->row_separator_data = NULL;
1689     }
1690
1691   gtk_tree_view_set_model (tree_view, NULL);
1692
1693   if (tree_view->priv->hadjustment)
1694     {
1695       g_object_unref (tree_view->priv->hadjustment);
1696       tree_view->priv->hadjustment = NULL;
1697     }
1698   if (tree_view->priv->vadjustment)
1699     {
1700       g_object_unref (tree_view->priv->vadjustment);
1701       tree_view->priv->vadjustment = NULL;
1702     }
1703
1704   GTK_OBJECT_CLASS (gtk_tree_view_parent_class)->destroy (object);
1705 }
1706
1707 \f
1708
1709 /* GtkWidget Methods
1710  */
1711
1712 /* GtkWidget::map helper */
1713 static void
1714 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
1715 {
1716   GList *list;
1717
1718   g_return_if_fail (GTK_WIDGET_MAPPED (tree_view));
1719
1720   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
1721     {
1722       GtkTreeViewColumn *column;
1723
1724       for (list = tree_view->priv->columns; list; list = list->next)
1725         {
1726           column = list->data;
1727           if (GTK_WIDGET_VISIBLE (column->button) &&
1728               !GTK_WIDGET_MAPPED (column->button))
1729             gtk_widget_map (column->button);
1730         }
1731       for (list = tree_view->priv->columns; list; list = list->next)
1732         {
1733           column = list->data;
1734           if (column->visible == FALSE)
1735             continue;
1736           if (column->resizable)
1737             {
1738               gdk_window_raise (column->window);
1739               gdk_window_show (column->window);
1740             }
1741           else
1742             gdk_window_hide (column->window);
1743         }
1744       gdk_window_show (tree_view->priv->header_window);
1745     }
1746 }
1747
1748 static void
1749 gtk_tree_view_map (GtkWidget *widget)
1750 {
1751   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1752   GList *tmp_list;
1753
1754   GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
1755
1756   tmp_list = tree_view->priv->children;
1757   while (tmp_list)
1758     {
1759       GtkTreeViewChild *child = tmp_list->data;
1760       tmp_list = tmp_list->next;
1761
1762       if (GTK_WIDGET_VISIBLE (child->widget))
1763         {
1764           if (!GTK_WIDGET_MAPPED (child->widget))
1765             gtk_widget_map (child->widget);
1766         }
1767     }
1768   gdk_window_show (tree_view->priv->bin_window);
1769
1770   gtk_tree_view_map_buttons (tree_view);
1771
1772   gdk_window_show (widget->window);
1773 }
1774
1775 static void
1776 gtk_tree_view_realize (GtkWidget *widget)
1777 {
1778   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1779   GList *tmp_list;
1780   GdkWindowAttr attributes;
1781   gint attributes_mask;
1782
1783   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1784
1785   /* Make the main, clipping window */
1786   attributes.window_type = GDK_WINDOW_CHILD;
1787   attributes.x = widget->allocation.x;
1788   attributes.y = widget->allocation.y;
1789   attributes.width = widget->allocation.width;
1790   attributes.height = widget->allocation.height;
1791   attributes.wclass = GDK_INPUT_OUTPUT;
1792   attributes.visual = gtk_widget_get_visual (widget);
1793   attributes.colormap = gtk_widget_get_colormap (widget);
1794   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
1795
1796   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1797
1798   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
1799                                    &attributes, attributes_mask);
1800   gdk_window_set_user_data (widget->window, widget);
1801
1802   /* Make the window for the tree */
1803   attributes.x = 0;
1804   attributes.y = TREE_VIEW_HEADER_HEIGHT (tree_view);
1805   attributes.width = MAX (tree_view->priv->width, widget->allocation.width);
1806   attributes.height = widget->allocation.height;
1807   attributes.event_mask = (GDK_EXPOSURE_MASK |
1808                            GDK_SCROLL_MASK |
1809                            GDK_POINTER_MOTION_MASK |
1810                            GDK_ENTER_NOTIFY_MASK |
1811                            GDK_LEAVE_NOTIFY_MASK |
1812                            GDK_BUTTON_PRESS_MASK |
1813                            GDK_BUTTON_RELEASE_MASK |
1814                            gtk_widget_get_events (widget));
1815
1816   tree_view->priv->bin_window = gdk_window_new (widget->window,
1817                                                 &attributes, attributes_mask);
1818   gdk_window_set_user_data (tree_view->priv->bin_window, widget);
1819
1820   /* Make the column header window */
1821   attributes.x = 0;
1822   attributes.y = 0;
1823   attributes.width = MAX (tree_view->priv->width, widget->allocation.width);
1824   attributes.height = tree_view->priv->header_height;
1825   attributes.event_mask = (GDK_EXPOSURE_MASK |
1826                            GDK_SCROLL_MASK |
1827                            GDK_BUTTON_PRESS_MASK |
1828                            GDK_BUTTON_RELEASE_MASK |
1829                            GDK_KEY_PRESS_MASK |
1830                            GDK_KEY_RELEASE_MASK |
1831                            gtk_widget_get_events (widget));
1832
1833   tree_view->priv->header_window = gdk_window_new (widget->window,
1834                                                    &attributes, attributes_mask);
1835   gdk_window_set_user_data (tree_view->priv->header_window, widget);
1836
1837   /* Add them all up. */
1838   widget->style = gtk_style_attach (widget->style, widget->window);
1839   gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
1840   gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
1841   gtk_style_set_background (widget->style, tree_view->priv->header_window, GTK_STATE_NORMAL);
1842
1843   tmp_list = tree_view->priv->children;
1844   while (tmp_list)
1845     {
1846       GtkTreeViewChild *child = tmp_list->data;
1847       tmp_list = tmp_list->next;
1848
1849       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
1850     }
1851
1852   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
1853     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
1854
1855   /* Need to call those here, since they create GCs */
1856   gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
1857   gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
1858
1859   install_presize_handler (tree_view);
1860 }
1861
1862 static void
1863 gtk_tree_view_unrealize (GtkWidget *widget)
1864 {
1865   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1866   GtkTreeViewPrivate *priv = tree_view->priv;
1867   GList *list;
1868
1869   if (priv->scroll_timeout != 0)
1870     {
1871       g_source_remove (priv->scroll_timeout);
1872       priv->scroll_timeout = 0;
1873     }
1874
1875   if (priv->auto_expand_timeout != 0)
1876     {
1877       g_source_remove (priv->auto_expand_timeout);
1878       priv->auto_expand_timeout = 0;
1879     }
1880
1881   if (priv->open_dest_timeout != 0)
1882     {
1883       g_source_remove (priv->open_dest_timeout);
1884       priv->open_dest_timeout = 0;
1885     }
1886
1887   remove_expand_collapse_timeout (tree_view);
1888
1889   if (priv->presize_handler_timer != 0)
1890     {
1891       g_source_remove (priv->presize_handler_timer);
1892       priv->presize_handler_timer = 0;
1893     }
1894
1895   if (priv->validate_rows_timer != 0)
1896     {
1897       g_source_remove (priv->validate_rows_timer);
1898       priv->validate_rows_timer = 0;
1899     }
1900
1901   if (priv->scroll_sync_timer != 0)
1902     {
1903       g_source_remove (priv->scroll_sync_timer);
1904       priv->scroll_sync_timer = 0;
1905     }
1906
1907   if (priv->typeselect_flush_timeout)
1908     {
1909       g_source_remove (priv->typeselect_flush_timeout);
1910       priv->typeselect_flush_timeout = 0;
1911     }
1912
1913   for (list = priv->columns; list; list = list->next)
1914     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
1915
1916   gdk_window_set_user_data (priv->bin_window, NULL);
1917   gdk_window_destroy (priv->bin_window);
1918   priv->bin_window = NULL;
1919
1920   gdk_window_set_user_data (priv->header_window, NULL);
1921   gdk_window_destroy (priv->header_window);
1922   priv->header_window = NULL;
1923
1924   if (priv->drag_window)
1925     {
1926       gdk_window_set_user_data (priv->drag_window, NULL);
1927       gdk_window_destroy (priv->drag_window);
1928       priv->drag_window = NULL;
1929     }
1930
1931   if (priv->drag_highlight_window)
1932     {
1933       gdk_window_set_user_data (priv->drag_highlight_window, NULL);
1934       gdk_window_destroy (priv->drag_highlight_window);
1935       priv->drag_highlight_window = NULL;
1936     }
1937
1938   if (priv->tree_line_gc)
1939     {
1940       g_object_unref (priv->tree_line_gc);
1941       priv->tree_line_gc = NULL;
1942     }
1943
1944   if (priv->grid_line_gc)
1945     {
1946       g_object_unref (priv->grid_line_gc);
1947       priv->grid_line_gc = NULL;
1948     }
1949
1950   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
1951 }
1952
1953 /* GtkWidget::size_request helper */
1954 static void
1955 gtk_tree_view_size_request_columns (GtkTreeView *tree_view)
1956 {
1957   GList *list;
1958
1959   tree_view->priv->header_height = 0;
1960
1961   if (tree_view->priv->model)
1962     {
1963       for (list = tree_view->priv->columns; list; list = list->next)
1964         {
1965           GtkRequisition requisition;
1966           GtkTreeViewColumn *column = list->data;
1967
1968           if (column->button == NULL)
1969             continue;
1970
1971           column = list->data;
1972
1973           gtk_widget_size_request (column->button, &requisition);
1974           column->button_request = requisition.width;
1975           tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
1976         }
1977     }
1978 }
1979
1980
1981 /* Called only by ::size_request */
1982 static void
1983 gtk_tree_view_update_size (GtkTreeView *tree_view)
1984 {
1985   GList *list;
1986   GtkTreeViewColumn *column;
1987   gint i;
1988
1989   if (tree_view->priv->model == NULL)
1990     {
1991       tree_view->priv->width = 0;
1992       tree_view->priv->prev_width = 0;
1993       tree_view->priv->height = 0;
1994       return;
1995     }
1996
1997   tree_view->priv->prev_width = tree_view->priv->width;
1998   tree_view->priv->width = 0;
1999
2000   /* keep this in sync with size_allocate below */
2001   for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
2002     {
2003       gint real_requested_width = 0;
2004       column = list->data;
2005       if (!column->visible)
2006         continue;
2007
2008       if (column->use_resized_width)
2009         {
2010           real_requested_width = column->resized_width;
2011         }
2012       else if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
2013         {
2014           real_requested_width = column->fixed_width;
2015         }
2016       else if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
2017         {
2018           real_requested_width = MAX (column->requested_width, column->button_request);
2019         }
2020       else
2021         {
2022           real_requested_width = column->requested_width;
2023         }
2024
2025       if (column->min_width != -1)
2026         real_requested_width = MAX (real_requested_width, column->min_width);
2027       if (column->max_width != -1)
2028         real_requested_width = MIN (real_requested_width, column->max_width);
2029
2030       tree_view->priv->width += real_requested_width;
2031     }
2032
2033   if (tree_view->priv->tree == NULL)
2034     tree_view->priv->height = 0;
2035   else
2036     tree_view->priv->height = tree_view->priv->tree->root->offset;
2037 }
2038
2039 static void
2040 gtk_tree_view_size_request (GtkWidget      *widget,
2041                             GtkRequisition *requisition)
2042 {
2043   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2044   GList *tmp_list;
2045
2046   /* we validate GTK_TREE_VIEW_NUM_ROWS_PER_IDLE rows initially just to make
2047    * sure we have some size. In practice, with a lot of static lists, this
2048    * 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_VISIBLE (child->widget))
2067         gtk_widget_size_request (child->widget, &child_requisition);
2068     }
2069 }
2070
2071
2072 static void
2073 invalidate_column (GtkTreeView       *tree_view,
2074                    GtkTreeViewColumn *column)
2075 {
2076   gint column_offset = 0;
2077   GList *list;
2078   GtkWidget *widget = GTK_WIDGET (tree_view);
2079   gboolean rtl;
2080
2081   if (!GTK_WIDGET_REALIZED (widget))
2082     return;
2083
2084   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2085   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2086        list;
2087        list = (rtl ? list->prev : list->next))
2088     {
2089       GtkTreeViewColumn *tmpcolumn = list->data;
2090       if (tmpcolumn == column)
2091         {
2092           GdkRectangle invalid_rect;
2093
2094           invalid_rect.x = column_offset;
2095           invalid_rect.y = 0;
2096           invalid_rect.width = column->width;
2097           invalid_rect.height = widget->allocation.height;
2098
2099           gdk_window_invalidate_rect (widget->window, &invalid_rect, TRUE);
2100           break;
2101         }
2102
2103       column_offset += tmpcolumn->width;
2104     }
2105 }
2106
2107 static void
2108 invalidate_last_column (GtkTreeView *tree_view)
2109 {
2110   GList *last_column;
2111   gboolean rtl;
2112
2113   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2114
2115   for (last_column = (rtl ? g_list_first (tree_view->priv->columns) : g_list_last (tree_view->priv->columns));
2116        last_column;
2117        last_column = (rtl ? last_column->next : last_column->prev))
2118     {
2119       if (GTK_TREE_VIEW_COLUMN (last_column->data)->visible)
2120         {
2121           invalidate_column (tree_view, last_column->data);
2122           return;
2123         }
2124     }
2125 }
2126
2127 static gint
2128 gtk_tree_view_get_real_requested_width_from_column (GtkTreeView       *tree_view,
2129                                                     GtkTreeViewColumn *column)
2130 {
2131   gint real_requested_width;
2132
2133   if (column->use_resized_width)
2134     {
2135       real_requested_width = column->resized_width;
2136     }
2137   else if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
2138     {
2139       real_requested_width = column->fixed_width;
2140     }
2141   else if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
2142     {
2143       real_requested_width = MAX (column->requested_width, column->button_request);
2144     }
2145   else
2146     {
2147       real_requested_width = column->requested_width;
2148       if (real_requested_width < 0)
2149         real_requested_width = 0;
2150     }
2151
2152   if (column->min_width != -1)
2153     real_requested_width = MAX (real_requested_width, column->min_width);
2154   if (column->max_width != -1)
2155     real_requested_width = MIN (real_requested_width, column->max_width);
2156
2157   return real_requested_width;
2158 }
2159
2160 /* GtkWidget::size_allocate helper */
2161 static void
2162 gtk_tree_view_size_allocate_columns (GtkWidget *widget,
2163                                      gboolean  *width_changed)
2164 {
2165   GtkTreeView *tree_view;
2166   GList *list, *first_column, *last_column;
2167   GtkTreeViewColumn *column;
2168   GtkAllocation allocation;
2169   gint width = 0;
2170   gint extra, extra_per_column, extra_for_last;
2171   gint full_requested_width = 0;
2172   gint number_of_expand_columns = 0;
2173   gboolean column_changed = FALSE;
2174   gboolean rtl;
2175   gboolean update_expand;
2176
2177   tree_view = GTK_TREE_VIEW (widget);
2178
2179   for (last_column = g_list_last (tree_view->priv->columns);
2180        last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible);
2181        last_column = last_column->prev)
2182     ;
2183   if (last_column == NULL)
2184     return;
2185
2186   for (first_column = g_list_first (tree_view->priv->columns);
2187        first_column && !(GTK_TREE_VIEW_COLUMN (first_column->data)->visible);
2188        first_column = first_column->next)
2189     ;
2190
2191   allocation.y = 0;
2192   allocation.height = tree_view->priv->header_height;
2193
2194   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2195
2196   /* find out how many extra space and expandable columns we have */
2197   for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
2198     {
2199       column = (GtkTreeViewColumn *)list->data;
2200
2201       if (!column->visible)
2202         continue;
2203
2204       full_requested_width += gtk_tree_view_get_real_requested_width_from_column (tree_view, column);
2205
2206       if (column->expand)
2207         number_of_expand_columns++;
2208     }
2209
2210   /* Only update the expand value if the width of the widget has changed,
2211    * or the number of expand columns has changed, or if there are no expand
2212    * columns, or if we didn't have an size-allocation yet after the
2213    * last validated node.
2214    */
2215   update_expand = (width_changed && *width_changed == TRUE)
2216       || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns
2217       || number_of_expand_columns == 0
2218       || tree_view->priv->post_validation_flag == TRUE;
2219
2220   tree_view->priv->post_validation_flag = FALSE;
2221
2222   if (!update_expand)
2223     {
2224       extra = tree_view->priv->last_extra_space;
2225       extra_for_last = MAX (widget->allocation.width - full_requested_width - extra, 0);
2226     }
2227   else
2228     {
2229       extra = MAX (widget->allocation.width - full_requested_width, 0);
2230       extra_for_last = 0;
2231
2232       tree_view->priv->last_extra_space = extra;
2233     }
2234
2235   if (number_of_expand_columns > 0)
2236     extra_per_column = extra/number_of_expand_columns;
2237   else
2238     extra_per_column = 0;
2239
2240   if (update_expand)
2241     {
2242       tree_view->priv->last_extra_space_per_column = extra_per_column;
2243       tree_view->priv->last_number_of_expand_columns = number_of_expand_columns;
2244     }
2245
2246   for (list = (rtl ? last_column : first_column);
2247        list != (rtl ? first_column->prev : last_column->next);
2248        list = (rtl ? list->prev : list->next))
2249     {
2250       gint real_requested_width = 0;
2251       gint old_width;
2252
2253       column = list->data;
2254       old_width = column->width;
2255
2256       if (!column->visible)
2257         continue;
2258
2259       /* We need to handle the dragged button specially.
2260        */
2261       if (column == tree_view->priv->drag_column)
2262         {
2263           GtkAllocation drag_allocation;
2264           gdk_drawable_get_size (tree_view->priv->drag_window,
2265                                  &(drag_allocation.width),
2266                                  &(drag_allocation.height));
2267           drag_allocation.x = 0;
2268           drag_allocation.y = 0;
2269           gtk_widget_size_allocate (tree_view->priv->drag_column->button,
2270                                     &drag_allocation);
2271           width += drag_allocation.width;
2272           continue;
2273         }
2274
2275       real_requested_width = gtk_tree_view_get_real_requested_width_from_column (tree_view, column);
2276
2277       allocation.x = width;
2278       column->width = real_requested_width;
2279
2280       if (column->expand)
2281         {
2282           if (number_of_expand_columns == 1)
2283             {
2284               /* We add the remander to the last column as
2285                * */
2286               column->width += extra;
2287             }
2288           else
2289             {
2290               column->width += extra_per_column;
2291               extra -= extra_per_column;
2292               number_of_expand_columns --;
2293             }
2294         }
2295       else if (number_of_expand_columns == 0 &&
2296                list == last_column)
2297         {
2298           column->width += extra;
2299         }
2300
2301       /* In addition to expand, the last column can get even more
2302        * extra space so all available space is filled up.
2303        */
2304       if (extra_for_last > 0 && list == last_column)
2305         column->width += extra_for_last;
2306
2307       g_object_notify (G_OBJECT (column), "width");
2308
2309       allocation.width = column->width;
2310       width += column->width;
2311
2312       if (column->width > old_width)
2313         column_changed = TRUE;
2314
2315       gtk_widget_size_allocate (column->button, &allocation);
2316
2317       if (column->window)
2318         gdk_window_move_resize (column->window,
2319                                 allocation.x + (rtl ? 0 : allocation.width) - TREE_VIEW_DRAG_WIDTH/2,
2320                                 allocation.y,
2321                                 TREE_VIEW_DRAG_WIDTH, allocation.height);
2322     }
2323
2324   /* We change the width here.  The user might have been resizing columns,
2325    * so the total width of the tree view changes.
2326    */
2327   tree_view->priv->width = width;
2328   if (width_changed)
2329     *width_changed = TRUE;
2330
2331   if (column_changed)
2332     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
2333 }
2334
2335
2336 static void
2337 gtk_tree_view_size_allocate (GtkWidget     *widget,
2338                              GtkAllocation *allocation)
2339 {
2340   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2341   GList *tmp_list;
2342   gboolean width_changed = FALSE;
2343   gint old_width = widget->allocation.width;
2344
2345   if (allocation->width != widget->allocation.width)
2346     width_changed = TRUE;
2347
2348   widget->allocation = *allocation;
2349
2350   tmp_list = tree_view->priv->children;
2351
2352   while (tmp_list)
2353     {
2354       GtkAllocation allocation;
2355
2356       GtkTreeViewChild *child = tmp_list->data;
2357       tmp_list = tmp_list->next;
2358
2359       /* totally ignore our child's requisition */
2360       allocation.x = child->x;
2361       allocation.y = child->y;
2362       allocation.width = child->width;
2363       allocation.height = child->height;
2364       gtk_widget_size_allocate (child->widget, &allocation);
2365     }
2366
2367   /* We size-allocate the columns first because the width of the
2368    * tree view (used in updating the adjustments below) might change.
2369    */
2370   gtk_tree_view_size_allocate_columns (widget, &width_changed);
2371
2372   tree_view->priv->hadjustment->page_size = allocation->width;
2373   tree_view->priv->hadjustment->page_increment = allocation->width * 0.9;
2374   tree_view->priv->hadjustment->step_increment = allocation->width * 0.1;
2375   tree_view->priv->hadjustment->lower = 0;
2376   tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->page_size, tree_view->priv->width);
2377
2378   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2379     {
2380       if (allocation->width < tree_view->priv->width)
2381         {
2382           if (tree_view->priv->init_hadjust_value)
2383             {
2384               tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
2385               tree_view->priv->init_hadjust_value = FALSE;
2386             }
2387           else if (allocation->width != old_width)
2388             {
2389               tree_view->priv->hadjustment->value = CLAMP (tree_view->priv->hadjustment->value - allocation->width + old_width, 0, tree_view->priv->width - allocation->width);
2390             }
2391           else
2392             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);
2393         }
2394       else
2395         {
2396           tree_view->priv->hadjustment->value = 0;
2397           tree_view->priv->init_hadjust_value = TRUE;
2398         }
2399     }
2400   else
2401     if (tree_view->priv->hadjustment->value + allocation->width > tree_view->priv->width)
2402       tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
2403
2404   gtk_adjustment_changed (tree_view->priv->hadjustment);
2405
2406   tree_view->priv->vadjustment->page_size = allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view);
2407   tree_view->priv->vadjustment->step_increment = tree_view->priv->vadjustment->page_size * 0.1;
2408   tree_view->priv->vadjustment->page_increment = tree_view->priv->vadjustment->page_size * 0.9;
2409   tree_view->priv->vadjustment->lower = 0;
2410   tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->page_size, tree_view->priv->height);
2411
2412   gtk_adjustment_changed (tree_view->priv->vadjustment);
2413
2414   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2415   if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
2416     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2417   else if (tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
2418     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2419                               tree_view->priv->height - tree_view->priv->vadjustment->page_size);
2420   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2421     gtk_tree_view_top_row_to_dy (tree_view);
2422   else
2423     gtk_tree_view_dy_to_top_row (tree_view);
2424
2425   if (GTK_WIDGET_REALIZED (widget))
2426     {
2427       gdk_window_move_resize (widget->window,
2428                               allocation->x, allocation->y,
2429                               allocation->width, allocation->height);
2430       gdk_window_move_resize (tree_view->priv->header_window,
2431                               - (gint) tree_view->priv->hadjustment->value,
2432                               0,
2433                               MAX (tree_view->priv->width, allocation->width),
2434                               tree_view->priv->header_height);
2435       gdk_window_move_resize (tree_view->priv->bin_window,
2436                               - (gint) tree_view->priv->hadjustment->value,
2437                               TREE_VIEW_HEADER_HEIGHT (tree_view),
2438                               MAX (tree_view->priv->width, allocation->width),
2439                               allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view));
2440     }
2441
2442   if (tree_view->priv->tree == NULL)
2443     invalidate_empty_focus (tree_view);
2444
2445   if (GTK_WIDGET_REALIZED (widget))
2446     {
2447       gboolean has_expand_column = FALSE;
2448       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2449         {
2450           if (gtk_tree_view_column_get_expand (GTK_TREE_VIEW_COLUMN (tmp_list->data)))
2451             {
2452               has_expand_column = TRUE;
2453               break;
2454             }
2455         }
2456
2457       /* This little hack only works if we have an LTR locale, and no column has the  */
2458       if (width_changed)
2459         {
2460           if (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_LTR &&
2461               ! has_expand_column)
2462             invalidate_last_column (tree_view);
2463           else
2464             gtk_widget_queue_draw (widget);
2465         }
2466     }
2467 }
2468
2469 /* Grabs the focus and unsets the GTK_TREE_VIEW_DRAW_KEYFOCUS flag */
2470 static void
2471 grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
2472 {
2473   if (GTK_WIDGET_CAN_FOCUS (tree_view) && !GTK_WIDGET_HAS_FOCUS (tree_view))
2474     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
2475   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
2476 }
2477
2478 static inline gboolean
2479 row_is_separator (GtkTreeView *tree_view,
2480                   GtkTreeIter *iter,
2481                   GtkTreePath *path)
2482 {
2483   gboolean is_separator = FALSE;
2484
2485   if (tree_view->priv->row_separator_func)
2486     {
2487       GtkTreeIter tmpiter;
2488
2489       if (iter)
2490         tmpiter = *iter;
2491       else
2492         gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path);
2493
2494       is_separator = tree_view->priv->row_separator_func (tree_view->priv->model,
2495                                                           &tmpiter,
2496                                                           tree_view->priv->row_separator_data);
2497     }
2498
2499   return is_separator;
2500 }
2501
2502 static gboolean
2503 gtk_tree_view_button_press (GtkWidget      *widget,
2504                             GdkEventButton *event)
2505 {
2506   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2507   GList *list;
2508   GtkTreeViewColumn *column = NULL;
2509   gint i;
2510   GdkRectangle background_area;
2511   GdkRectangle cell_area;
2512   gint vertical_separator;
2513   gint horizontal_separator;
2514   gboolean path_is_selectable;
2515   gboolean rtl;
2516
2517   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2518   gtk_tree_view_stop_editing (tree_view, FALSE);
2519   gtk_widget_style_get (widget,
2520                         "vertical-separator", &vertical_separator,
2521                         "horizontal-separator", &horizontal_separator,
2522                         NULL);
2523
2524
2525   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2526    * we're done handling the button press.
2527    */
2528
2529   if (event->window == tree_view->priv->bin_window)
2530     {
2531       GtkRBNode *node;
2532       GtkRBTree *tree;
2533       GtkTreePath *path;
2534       gchar *path_string;
2535       gint depth;
2536       gint new_y;
2537       gint y_offset;
2538       gint dval;
2539       gint pre_val, aft_val;
2540       GtkTreeViewColumn *column = NULL;
2541       GtkCellRenderer *focus_cell = NULL;
2542       gint column_handled_click = FALSE;
2543       gboolean row_double_click = FALSE;
2544       gboolean rtl;
2545       gboolean node_selected;
2546
2547       /* Empty tree? */
2548       if (tree_view->priv->tree == NULL)
2549         {
2550           grab_focus_and_unset_draw_keyfocus (tree_view);
2551           return TRUE;
2552         }
2553
2554       /* are we in an arrow? */
2555       if (tree_view->priv->prelight_node &&
2556           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT) &&
2557           TREE_VIEW_DRAW_EXPANDERS (tree_view))
2558         {
2559           if (event->button == 1)
2560             {
2561               gtk_grab_add (widget);
2562               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2563               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2564               gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
2565                                         tree_view->priv->prelight_tree,
2566                                         tree_view->priv->prelight_node,
2567                                         event->x,
2568                                         event->y);
2569             }
2570
2571           grab_focus_and_unset_draw_keyfocus (tree_view);
2572           return TRUE;
2573         }
2574
2575       /* find the node that was clicked */
2576       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
2577       if (new_y < 0)
2578         new_y = 0;
2579       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
2580
2581       if (node == NULL)
2582         {
2583           /* We clicked in dead space */
2584           grab_focus_and_unset_draw_keyfocus (tree_view);
2585           return TRUE;
2586         }
2587
2588       /* Get the path and the node */
2589       path = _gtk_tree_view_find_path (tree_view, tree, node);
2590       path_is_selectable = !row_is_separator (tree_view, NULL, path);
2591
2592       if (!path_is_selectable)
2593         {
2594           gtk_tree_path_free (path);
2595           grab_focus_and_unset_draw_keyfocus (tree_view);
2596           return TRUE;
2597         }
2598
2599       depth = gtk_tree_path_get_depth (path);
2600       background_area.y = y_offset + event->y;
2601       background_area.height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
2602       background_area.x = 0;
2603
2604
2605       /* Let the column have a chance at selecting it. */
2606       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2607       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2608            list; list = (rtl ? list->prev : list->next))
2609         {
2610           GtkTreeViewColumn *candidate = list->data;
2611
2612           if (!candidate->visible)
2613             continue;
2614
2615           background_area.width = candidate->width;
2616           if ((background_area.x > (gint) event->x) ||
2617               (background_area.x + background_area.width <= (gint) event->x))
2618             {
2619               background_area.x += background_area.width;
2620               continue;
2621             }
2622
2623           /* we found the focus column */
2624           column = candidate;
2625           cell_area = background_area;
2626           cell_area.width -= horizontal_separator;
2627           cell_area.height -= vertical_separator;
2628           cell_area.x += horizontal_separator/2;
2629           cell_area.y += vertical_separator/2;
2630           if (gtk_tree_view_is_expander_column (tree_view, column))
2631             {
2632               if (!rtl)
2633                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
2634               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
2635
2636               if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
2637                 {
2638                   if (!rtl)
2639                     cell_area.x += depth * tree_view->priv->expander_size;
2640                   cell_area.width -= depth * tree_view->priv->expander_size;
2641                 }
2642             }
2643           break;
2644         }
2645
2646       if (column == NULL)
2647         {
2648           gtk_tree_path_free (path);
2649           grab_focus_and_unset_draw_keyfocus (tree_view);
2650           return FALSE;
2651         }
2652
2653       tree_view->priv->focus_column = column;
2654
2655       /* decide if we edit */
2656       if (event->type == GDK_BUTTON_PRESS && event->button == 1 &&
2657           !(event->state & gtk_accelerator_get_default_mod_mask ()))
2658         {
2659           GtkTreePath *anchor;
2660           GtkTreeIter iter;
2661
2662           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
2663           gtk_tree_view_column_cell_set_cell_data (column,
2664                                                    tree_view->priv->model,
2665                                                    &iter,
2666                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
2667                                                    node->children?TRUE:FALSE);
2668
2669           if (tree_view->priv->anchor)
2670             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
2671           else
2672             anchor = NULL;
2673
2674           if ((anchor && !gtk_tree_path_compare (anchor, path))
2675               || !_gtk_tree_view_column_has_editable_cell (column))
2676             {
2677               GtkCellEditable *cell_editable = NULL;
2678
2679               /* FIXME: get the right flags */
2680               guint flags = 0;
2681
2682               path_string = gtk_tree_path_to_string (path);
2683
2684               if (_gtk_tree_view_column_cell_event (column,
2685                                                     &cell_editable,
2686                                                     (GdkEvent *)event,
2687                                                     path_string,
2688                                                     &background_area,
2689                                                     &cell_area, flags))
2690                 {
2691                   if (cell_editable != NULL)
2692                     {
2693                       gint left, right;
2694                       GdkRectangle area;
2695
2696                       area = cell_area;
2697                       _gtk_tree_view_column_get_neighbor_sizes (column, _gtk_tree_view_column_get_edited_cell (column), &left, &right);
2698
2699                       area.x += left;
2700                       area.width -= right + left;
2701
2702                       gtk_tree_view_real_start_editing (tree_view,
2703                                                         column,
2704                                                         path,
2705                                                         cell_editable,
2706                                                         &area,
2707                                                         (GdkEvent *)event,
2708                                                         flags);
2709                       g_free (path_string);
2710                       gtk_tree_path_free (path);
2711                       gtk_tree_path_free (anchor);
2712                       return TRUE;
2713                     }
2714                   column_handled_click = TRUE;
2715                 }
2716               g_free (path_string);
2717             }
2718           if (anchor)
2719             gtk_tree_path_free (anchor);
2720         }
2721
2722       /* select */
2723       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
2724       pre_val = tree_view->priv->vadjustment->value;
2725
2726       /* we only handle selection modifications on the first button press
2727        */
2728       if (event->type == GDK_BUTTON_PRESS)
2729         {
2730           if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
2731             tree_view->priv->ctrl_pressed = TRUE;
2732           if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
2733             tree_view->priv->shift_pressed = TRUE;
2734
2735           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column, event->x - background_area.x);
2736           if (focus_cell)
2737             gtk_tree_view_column_focus_cell (column, focus_cell);
2738
2739           if (event->state & GDK_CONTROL_MASK)
2740             {
2741               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
2742               gtk_tree_view_real_toggle_cursor_row (tree_view);
2743             }
2744           else if (event->state & GDK_SHIFT_MASK)
2745             {
2746               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
2747               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
2748             }
2749           else
2750             {
2751               gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
2752             }
2753
2754           tree_view->priv->ctrl_pressed = FALSE;
2755           tree_view->priv->shift_pressed = FALSE;
2756         }
2757
2758       /* the treeview may have been scrolled because of _set_cursor,
2759        * correct here
2760        */
2761
2762       aft_val = tree_view->priv->vadjustment->value;
2763       dval = pre_val - aft_val;
2764
2765       cell_area.y += dval;
2766       background_area.y += dval;
2767
2768       /* Save press to possibly begin a drag
2769        */
2770       if (!column_handled_click &&
2771           !tree_view->priv->in_grab &&
2772           tree_view->priv->pressed_button < 0)
2773         {
2774           tree_view->priv->pressed_button = event->button;
2775           tree_view->priv->press_start_x = event->x;
2776           tree_view->priv->press_start_y = event->y;
2777
2778           if (tree_view->priv->rubber_banding_enable
2779               && !node_selected
2780               && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE)
2781             {
2782               tree_view->priv->press_start_y += tree_view->priv->dy;
2783               tree_view->priv->rubber_band_x = event->x;
2784               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
2785               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
2786
2787               if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
2788                 tree_view->priv->rubber_band_ctrl = TRUE;
2789               if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
2790                 tree_view->priv->rubber_band_shift = TRUE;
2791             }
2792         }
2793
2794       /* Test if a double click happened on the same row. */
2795       if (event->button == 1)
2796         {
2797           /* We also handle triple clicks here, because a user could have done
2798            * a first click and a second double click on different rows.
2799            */
2800           if ((event->type == GDK_2BUTTON_PRESS
2801                || event->type == GDK_3BUTTON_PRESS)
2802               && tree_view->priv->last_button_press)
2803             {
2804               GtkTreePath *lsc;
2805
2806               lsc = gtk_tree_row_reference_get_path (tree_view->priv->last_button_press);
2807
2808               if (lsc)
2809                 {
2810                   row_double_click = !gtk_tree_path_compare (lsc, path);
2811                   gtk_tree_path_free (lsc);
2812                 }
2813             }
2814
2815           if (row_double_click)
2816             {
2817               if (tree_view->priv->last_button_press)
2818                 gtk_tree_row_reference_free (tree_view->priv->last_button_press);
2819               if (tree_view->priv->last_button_press_2)
2820                 gtk_tree_row_reference_free (tree_view->priv->last_button_press_2);
2821               tree_view->priv->last_button_press = NULL;
2822               tree_view->priv->last_button_press_2 = NULL;
2823             }
2824           else
2825             {
2826               if (tree_view->priv->last_button_press)
2827                 gtk_tree_row_reference_free (tree_view->priv->last_button_press);
2828               tree_view->priv->last_button_press = tree_view->priv->last_button_press_2;
2829               tree_view->priv->last_button_press_2 = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
2830             }
2831         }
2832
2833       if (row_double_click)
2834         {
2835           gtk_grab_remove (widget);
2836           gtk_tree_view_row_activated (tree_view, path, column);
2837
2838           if (tree_view->priv->pressed_button == event->button)
2839             tree_view->priv->pressed_button = -1;
2840         }
2841
2842       gtk_tree_path_free (path);
2843
2844       /* If we activated the row through a double click we don't want to grab
2845        * focus back, as moving focus to another widget is pretty common.
2846        */
2847       if (!row_double_click)
2848         grab_focus_and_unset_draw_keyfocus (tree_view);
2849
2850       return TRUE;
2851     }
2852
2853   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
2854    */
2855   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
2856     {
2857       column = list->data;
2858       if (event->window == column->window &&
2859           column->resizable &&
2860           column->window)
2861         {
2862           gpointer drag_data;
2863
2864           if (event->type == GDK_2BUTTON_PRESS &&
2865               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
2866             {
2867               column->use_resized_width = FALSE;
2868               _gtk_tree_view_column_autosize (tree_view, column);
2869               return TRUE;
2870             }
2871
2872           if (gdk_pointer_grab (column->window, FALSE,
2873                                 GDK_POINTER_MOTION_HINT_MASK |
2874                                 GDK_BUTTON1_MOTION_MASK |
2875                                 GDK_BUTTON_RELEASE_MASK,
2876                                 NULL, NULL, event->time))
2877             return FALSE;
2878
2879           gtk_grab_add (widget);
2880           GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
2881           column->resized_width = column->width - tree_view->priv->last_extra_space_per_column;
2882
2883           /* block attached dnd signal handler */
2884           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
2885           if (drag_data)
2886             g_signal_handlers_block_matched (widget,
2887                                              G_SIGNAL_MATCH_DATA,
2888                                              0, 0, NULL, NULL,
2889                                              drag_data);
2890
2891           tree_view->priv->drag_pos = i;
2892           tree_view->priv->x_drag = column->button->allocation.x + (rtl ? 0 : column->button->allocation.width);
2893
2894           if (!GTK_WIDGET_HAS_FOCUS (widget))
2895             gtk_widget_grab_focus (widget);
2896
2897           return TRUE;
2898         }
2899     }
2900   return FALSE;
2901 }
2902
2903 /* GtkWidget::button_release_event helper */
2904 static gboolean
2905 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
2906                                           GdkEventButton *event)
2907 {
2908   GtkTreeView *tree_view;
2909   GList *l;
2910   gboolean rtl;
2911
2912   tree_view = GTK_TREE_VIEW (widget);
2913
2914   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2915   gdk_display_pointer_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME);
2916   gdk_display_keyboard_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME);
2917
2918   /* Move the button back */
2919   g_object_ref (tree_view->priv->drag_column->button);
2920   gtk_container_remove (GTK_CONTAINER (tree_view), tree_view->priv->drag_column->button);
2921   gtk_widget_set_parent_window (tree_view->priv->drag_column->button, tree_view->priv->header_window);
2922   gtk_widget_set_parent (tree_view->priv->drag_column->button, GTK_WIDGET (tree_view));
2923   g_object_unref (tree_view->priv->drag_column->button);
2924   gtk_widget_queue_resize (widget);
2925   if (tree_view->priv->drag_column->resizable)
2926     {
2927       gdk_window_raise (tree_view->priv->drag_column->window);
2928       gdk_window_show (tree_view->priv->drag_column->window);
2929     }
2930   else
2931     gdk_window_hide (tree_view->priv->drag_column->window);
2932
2933   gtk_widget_grab_focus (tree_view->priv->drag_column->button);
2934
2935   if (rtl)
2936     {
2937       if (tree_view->priv->cur_reorder &&
2938           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
2939         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
2940                                          tree_view->priv->cur_reorder->right_column);
2941     }
2942   else
2943     {
2944       if (tree_view->priv->cur_reorder &&
2945           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
2946         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
2947                                          tree_view->priv->cur_reorder->left_column);
2948     }
2949   tree_view->priv->drag_column = NULL;
2950   gdk_window_hide (tree_view->priv->drag_window);
2951
2952   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
2953     g_slice_free (GtkTreeViewColumnReorder, l->data);
2954   g_list_free (tree_view->priv->column_drag_info);
2955   tree_view->priv->column_drag_info = NULL;
2956   tree_view->priv->cur_reorder = NULL;
2957
2958   if (tree_view->priv->drag_highlight_window)
2959     gdk_window_hide (tree_view->priv->drag_highlight_window);
2960
2961   /* Reset our flags */
2962   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
2963   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG);
2964
2965   return TRUE;
2966 }
2967
2968 /* GtkWidget::button_release_event helper */
2969 static gboolean
2970 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
2971                                             GdkEventButton *event)
2972 {
2973   GtkTreeView *tree_view;
2974   gpointer drag_data;
2975
2976   tree_view = GTK_TREE_VIEW (widget);
2977
2978   tree_view->priv->drag_pos = -1;
2979
2980   /* unblock attached dnd signal handler */
2981   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
2982   if (drag_data)
2983     g_signal_handlers_unblock_matched (widget,
2984                                        G_SIGNAL_MATCH_DATA,
2985                                        0, 0, NULL, NULL,
2986                                        drag_data);
2987
2988   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
2989   gtk_grab_remove (widget);
2990   gdk_display_pointer_ungrab (gdk_drawable_get_display (event->window),
2991                               event->time);
2992   return TRUE;
2993 }
2994
2995 static gboolean
2996 gtk_tree_view_button_release (GtkWidget      *widget,
2997                               GdkEventButton *event)
2998 {
2999   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3000
3001   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
3002     return gtk_tree_view_button_release_drag_column (widget, event);
3003
3004   if (tree_view->priv->rubber_band_status)
3005     gtk_tree_view_stop_rubber_band (tree_view);
3006
3007   if (tree_view->priv->pressed_button == event->button)
3008     tree_view->priv->pressed_button = -1;
3009
3010   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
3011     return gtk_tree_view_button_release_column_resize (widget, event);
3012
3013   if (tree_view->priv->button_pressed_node == NULL)
3014     return FALSE;
3015
3016   if (event->button == 1)
3017     {
3018       gtk_grab_remove (widget);
3019       if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
3020           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
3021         {
3022           GtkTreePath *path = NULL;
3023
3024           path = _gtk_tree_view_find_path (tree_view,
3025                                            tree_view->priv->button_pressed_tree,
3026                                            tree_view->priv->button_pressed_node);
3027           /* Actually activate the node */
3028           if (tree_view->priv->button_pressed_node->children == NULL)
3029             gtk_tree_view_real_expand_row (tree_view, path,
3030                                            tree_view->priv->button_pressed_tree,
3031                                            tree_view->priv->button_pressed_node,
3032                                            FALSE, TRUE);
3033           else
3034             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3035                                              tree_view->priv->button_pressed_tree,
3036                                              tree_view->priv->button_pressed_node, TRUE);
3037           gtk_tree_path_free (path);
3038         }
3039
3040       tree_view->priv->button_pressed_tree = NULL;
3041       tree_view->priv->button_pressed_node = NULL;
3042     }
3043
3044   return TRUE;
3045 }
3046
3047 static gboolean
3048 gtk_tree_view_grab_broken (GtkWidget          *widget,
3049                            GdkEventGrabBroken *event)
3050 {
3051   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3052
3053   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
3054     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3055
3056   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
3057     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3058
3059   return TRUE;
3060 }
3061
3062 #if 0
3063 static gboolean
3064 gtk_tree_view_configure (GtkWidget *widget,
3065                          GdkEventConfigure *event)
3066 {
3067   GtkTreeView *tree_view;
3068
3069   tree_view = GTK_TREE_VIEW (widget);
3070   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3071
3072   return FALSE;
3073 }
3074 #endif
3075
3076 /* GtkWidget::motion_event function set.
3077  */
3078
3079 static gboolean
3080 coords_are_over_arrow (GtkTreeView *tree_view,
3081                        GtkRBTree   *tree,
3082                        GtkRBNode   *node,
3083                        /* these are in bin window coords */
3084                        gint         x,
3085                        gint         y)
3086 {
3087   GdkRectangle arrow;
3088   gint x2;
3089
3090   if (!GTK_WIDGET_REALIZED (tree_view))
3091     return FALSE;
3092
3093   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3094     return FALSE;
3095
3096   arrow.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
3097
3098   arrow.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
3099
3100   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3101
3102   arrow.width = x2 - arrow.x;
3103
3104   return (x >= arrow.x &&
3105           x < (arrow.x + arrow.width) &&
3106           y >= arrow.y &&
3107           y < (arrow.y + arrow.height));
3108 }
3109
3110 static gboolean
3111 auto_expand_timeout (gpointer data)
3112 {
3113   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3114   GtkTreePath *path;
3115
3116   if (tree_view->priv->prelight_node)
3117     {
3118       path = _gtk_tree_view_find_path (tree_view,
3119                                        tree_view->priv->prelight_tree,
3120                                        tree_view->priv->prelight_node);
3121
3122       if (tree_view->priv->prelight_node->children)
3123         gtk_tree_view_collapse_row (tree_view, path);
3124       else
3125         gtk_tree_view_expand_row (tree_view, path, FALSE);
3126
3127       gtk_tree_path_free (path);
3128     }
3129
3130   tree_view->priv->auto_expand_timeout = 0;
3131
3132   return FALSE;
3133 }
3134
3135 static void
3136 remove_auto_expand_timeout (GtkTreeView *tree_view)
3137 {
3138   if (tree_view->priv->auto_expand_timeout != 0)
3139     {
3140       g_source_remove (tree_view->priv->auto_expand_timeout);
3141       tree_view->priv->auto_expand_timeout = 0;
3142     }
3143 }
3144
3145 static void
3146 do_prelight (GtkTreeView *tree_view,
3147              GtkRBTree   *tree,
3148              GtkRBNode   *node,
3149              /* these are in bin_window coords */
3150              gint         x,
3151              gint         y)
3152 {
3153   if (tree_view->priv->prelight_tree == tree &&
3154       tree_view->priv->prelight_node == node)
3155     {
3156       /*  We are still on the same node,
3157           but we might need to take care of the arrow  */
3158
3159       if (tree && node && TREE_VIEW_DRAW_EXPANDERS (tree_view))
3160         {
3161           gboolean over_arrow;
3162           gboolean flag_set;
3163
3164           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3165           flag_set = GTK_TREE_VIEW_FLAG_SET (tree_view,
3166                                              GTK_TREE_VIEW_ARROW_PRELIT);
3167
3168           if (over_arrow != flag_set)
3169             {
3170               if (over_arrow)
3171                 GTK_TREE_VIEW_SET_FLAG (tree_view,
3172                                         GTK_TREE_VIEW_ARROW_PRELIT);
3173               else
3174                 GTK_TREE_VIEW_UNSET_FLAG (tree_view,
3175                                           GTK_TREE_VIEW_ARROW_PRELIT);
3176
3177               gtk_tree_view_draw_arrow (tree_view, tree, node, x, y);
3178             }
3179         }
3180
3181       return;
3182     }
3183
3184   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3185     {
3186       /*  Unprelight the old node and arrow  */
3187
3188       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3189                              GTK_RBNODE_IS_PRELIT);
3190
3191       if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT)
3192           && TREE_VIEW_DRAW_EXPANDERS (tree_view))
3193         {
3194           GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
3195
3196           gtk_tree_view_draw_arrow (tree_view,
3197                                     tree_view->priv->prelight_tree,
3198                                     tree_view->priv->prelight_node,
3199                                     x,
3200                                     y);
3201         }
3202
3203       _gtk_tree_view_queue_draw_node (tree_view,
3204                                       tree_view->priv->prelight_tree,
3205                                       tree_view->priv->prelight_node,
3206                                       NULL);
3207     }
3208
3209
3210   if (tree_view->priv->hover_expand)
3211     remove_auto_expand_timeout (tree_view);
3212
3213   /*  Set the new prelight values  */
3214   tree_view->priv->prelight_node = node;
3215   tree_view->priv->prelight_tree = tree;
3216
3217   if (!node || !tree)
3218     return;
3219
3220   /*  Prelight the new node and arrow  */
3221
3222   if (TREE_VIEW_DRAW_EXPANDERS (tree_view)
3223       && coords_are_over_arrow (tree_view, tree, node, x, y))
3224     {
3225       GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
3226
3227       gtk_tree_view_draw_arrow (tree_view, tree, node, x, y);
3228     }
3229
3230   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3231
3232   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3233
3234   if (tree_view->priv->hover_expand)
3235     {
3236       tree_view->priv->auto_expand_timeout =
3237         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3238     }
3239 }
3240
3241 static void
3242 prelight_or_select (GtkTreeView *tree_view,
3243                     GtkRBTree   *tree,
3244                     GtkRBNode   *node,
3245                     /* these are in bin_window coords */
3246                     gint         x,
3247                     gint         y)
3248 {
3249   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3250
3251   if (tree_view->priv->hover_selection &&
3252       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3253       !(tree_view->priv->edited_column &&
3254         tree_view->priv->edited_column->editable_widget))
3255     {
3256       if (node)
3257         {
3258           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3259             {
3260               GtkTreePath *path;
3261
3262               path = _gtk_tree_view_find_path (tree_view, tree, node);
3263               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3264               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3265                 {
3266                   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
3267                   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE);
3268                 }
3269               gtk_tree_path_free (path);
3270             }
3271         }
3272
3273       else if (mode == GTK_SELECTION_SINGLE)
3274         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3275     }
3276
3277     do_prelight (tree_view, tree, node, x, y);
3278 }
3279
3280 static void
3281 ensure_unprelighted (GtkTreeView *tree_view)
3282 {
3283   do_prelight (tree_view,
3284                NULL, NULL,
3285                -1000, -1000); /* coords not possibly over an arrow */
3286
3287   g_assert (tree_view->priv->prelight_node == NULL);
3288 }
3289
3290
3291
3292
3293 /* Our motion arrow is either a box (in the case of the original spot)
3294  * or an arrow.  It is expander_size wide.
3295  */
3296 /*
3297  * 11111111111111
3298  * 01111111111110
3299  * 00111111111100
3300  * 00011111111000
3301  * 00001111110000
3302  * 00000111100000
3303  * 00000111100000
3304  * 00000111100000
3305  * ~ ~ ~ ~ ~ ~ ~
3306  * 00000111100000
3307  * 00000111100000
3308  * 00000111100000
3309  * 00001111110000
3310  * 00011111111000
3311  * 00111111111100
3312  * 01111111111110
3313  * 11111111111111
3314  */
3315
3316 static void
3317 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3318 {
3319   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3320   GtkWidget *widget = GTK_WIDGET (tree_view);
3321   GdkBitmap *mask = NULL;
3322   gint x;
3323   gint y;
3324   gint width;
3325   gint height;
3326   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3327   GdkWindowAttr attributes;
3328   guint attributes_mask;
3329
3330   if (!reorder ||
3331       reorder->left_column == tree_view->priv->drag_column ||
3332       reorder->right_column == tree_view->priv->drag_column)
3333     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3334   else if (reorder->left_column || reorder->right_column)
3335     {
3336       GdkRectangle visible_rect;
3337       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3338       if (reorder->left_column)
3339         x = reorder->left_column->button->allocation.x + reorder->left_column->button->allocation.width;
3340       else
3341         x = reorder->right_column->button->allocation.x;
3342
3343       if (x < visible_rect.x)
3344         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3345       else if (x > visible_rect.x + visible_rect.width)
3346         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3347       else
3348         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3349     }
3350
3351   /* We want to draw the rectangle over the initial location. */
3352   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3353     {
3354       GdkGC *gc;
3355       GdkColor col;
3356
3357       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3358         {
3359           if (tree_view->priv->drag_highlight_window)
3360             {
3361               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3362                                         NULL);
3363               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3364             }
3365
3366           attributes.window_type = GDK_WINDOW_CHILD;
3367           attributes.wclass = GDK_INPUT_OUTPUT;
3368           attributes.x = tree_view->priv->drag_column_x;
3369           attributes.y = 0;
3370           width = attributes.width = tree_view->priv->drag_column->button->allocation.width;
3371           height = attributes.height = tree_view->priv->drag_column->button->allocation.height;
3372           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3373           attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
3374           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3375           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
3376           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3377           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3378
3379           mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width, height, 1);
3380           gc = gdk_gc_new (mask);
3381           col.pixel = 1;
3382           gdk_gc_set_foreground (gc, &col);
3383           gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
3384           col.pixel = 0;
3385           gdk_gc_set_foreground(gc, &col);
3386           gdk_draw_rectangle (mask, gc, TRUE, 2, 2, width - 4, height - 4);
3387           g_object_unref (gc);
3388
3389           gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
3390                                          mask, 0, 0);
3391           if (mask) g_object_unref (mask);
3392           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3393         }
3394     }
3395   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3396     {
3397       gint i, j = 1;
3398       GdkGC *gc;
3399       GdkColor col;
3400
3401       width = tree_view->priv->expander_size;
3402
3403       /* Get x, y, width, height of arrow */
3404       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3405       if (reorder->left_column)
3406         {
3407           x += reorder->left_column->button->allocation.x + reorder->left_column->button->allocation.width - width/2;
3408           height = reorder->left_column->button->allocation.height;
3409         }
3410       else
3411         {
3412           x += reorder->right_column->button->allocation.x - width/2;
3413           height = reorder->right_column->button->allocation.height;
3414         }
3415       y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */
3416       height += tree_view->priv->expander_size;
3417
3418       /* Create the new window */
3419       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3420         {
3421           if (tree_view->priv->drag_highlight_window)
3422             {
3423               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3424                                         NULL);
3425               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3426             }
3427
3428           attributes.window_type = GDK_WINDOW_TEMP;
3429           attributes.wclass = GDK_INPUT_OUTPUT;
3430           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3431           attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
3432           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3433           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
3434           attributes.x = x;
3435           attributes.y = y;
3436           attributes.width = width;
3437           attributes.height = height;
3438           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3439                                                                    &attributes, attributes_mask);
3440           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3441
3442           mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width, height, 1);
3443           gc = gdk_gc_new (mask);
3444           col.pixel = 1;
3445           gdk_gc_set_foreground (gc, &col);
3446           gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
3447
3448           /* Draw the 2 arrows as per above */
3449           col.pixel = 0;
3450           gdk_gc_set_foreground (gc, &col);
3451           for (i = 0; i < width; i ++)
3452             {
3453               if (i == (width/2 - 1))
3454                 continue;
3455               gdk_draw_line (mask, gc, i, j, i, height - j);
3456               if (i < (width/2 - 1))
3457                 j++;
3458               else
3459                 j--;
3460             }
3461           g_object_unref (gc);
3462           gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
3463                                          mask, 0, 0);
3464           if (mask) g_object_unref (mask);
3465         }
3466
3467       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3468       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3469     }
3470   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3471            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3472     {
3473       gint i, j = 1;
3474       GdkGC *gc;
3475       GdkColor col;
3476
3477       width = tree_view->priv->expander_size;
3478
3479       /* Get x, y, width, height of arrow */
3480       width = width/2; /* remember, the arrow only takes half the available width */
3481       gdk_window_get_origin (widget->window, &x, &y);
3482       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3483         x += widget->allocation.width - width;
3484
3485       if (reorder->left_column)
3486         height = reorder->left_column->button->allocation.height;
3487       else
3488         height = reorder->right_column->button->allocation.height;
3489
3490       y -= tree_view->priv->expander_size;
3491       height += 2*tree_view->priv->expander_size;
3492
3493       /* Create the new window */
3494       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3495           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3496         {
3497           if (tree_view->priv->drag_highlight_window)
3498             {
3499               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3500                                         NULL);
3501               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3502             }
3503
3504           attributes.window_type = GDK_WINDOW_TEMP;
3505           attributes.wclass = GDK_INPUT_OUTPUT;
3506           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3507           attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
3508           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3509           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
3510           attributes.x = x;
3511           attributes.y = y;
3512           attributes.width = width;
3513           attributes.height = height;
3514           tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
3515           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3516
3517           mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width, height, 1);
3518           gc = gdk_gc_new (mask);
3519           col.pixel = 1;
3520           gdk_gc_set_foreground (gc, &col);
3521           gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
3522
3523           /* Draw the 2 arrows as per above */
3524           col.pixel = 0;
3525           gdk_gc_set_foreground (gc, &col);
3526           j = tree_view->priv->expander_size;
3527           for (i = 0; i < width; i ++)
3528             {
3529               gint k;
3530               if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3531                 k = width - i - 1;
3532               else
3533                 k = i;
3534               gdk_draw_line (mask, gc, k, j, k, height - j);
3535               gdk_draw_line (mask, gc, k, 0, k, tree_view->priv->expander_size - j);
3536               gdk_draw_line (mask, gc, k, height, k, height - tree_view->priv->expander_size + j);
3537               j--;
3538             }
3539           g_object_unref (gc);
3540           gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
3541                                          mask, 0, 0);
3542           if (mask) g_object_unref (mask);
3543         }
3544
3545       tree_view->priv->drag_column_window_state = arrow_type;
3546       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3547    }
3548   else
3549     {
3550       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
3551       gdk_window_hide (tree_view->priv->drag_highlight_window);
3552       return;
3553     }
3554
3555   gdk_window_show (tree_view->priv->drag_highlight_window);
3556   gdk_window_raise (tree_view->priv->drag_highlight_window);
3557 }
3558
3559 static gboolean
3560 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
3561                                     GdkEventMotion *event)
3562 {
3563   gint x;
3564   gint new_width;
3565   GtkTreeViewColumn *column;
3566   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3567
3568   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
3569
3570   if (event->is_hint || event->window != widget->window)
3571     gtk_widget_get_pointer (widget, &x, NULL);
3572   else
3573     x = event->x;
3574
3575   if (tree_view->priv->hadjustment)
3576     x += tree_view->priv->hadjustment->value;
3577
3578   new_width = gtk_tree_view_new_column_width (tree_view,
3579                                               tree_view->priv->drag_pos, &x);
3580   if (x != tree_view->priv->x_drag &&
3581       (new_width != column->fixed_width))
3582     {
3583       column->use_resized_width = TRUE;
3584       column->resized_width = new_width;
3585       if (column->expand)
3586         column->resized_width -= tree_view->priv->last_extra_space_per_column;
3587       gtk_widget_queue_resize (widget);
3588     }
3589
3590   return FALSE;
3591 }
3592
3593
3594 static void
3595 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view)
3596 {
3597   GtkTreeViewColumnReorder *reorder = NULL;
3598   GList *list;
3599   gint mouse_x;
3600
3601   gdk_window_get_pointer (tree_view->priv->header_window, &mouse_x, NULL, NULL);
3602   for (list = tree_view->priv->column_drag_info; list; list = list->next)
3603     {
3604       reorder = (GtkTreeViewColumnReorder *) list->data;
3605       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
3606         break;
3607       reorder = NULL;
3608     }
3609
3610   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
3611       return;*/
3612
3613   tree_view->priv->cur_reorder = reorder;
3614   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
3615 }
3616
3617 static void
3618 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
3619 {
3620   GdkRectangle visible_rect;
3621   gint y;
3622   gint offset;
3623
3624   gdk_window_get_pointer (tree_view->priv->bin_window, NULL, &y, NULL);
3625   y += tree_view->priv->dy;
3626
3627   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3628
3629   /* see if we are near the edge. */
3630   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
3631   if (offset > 0)
3632     {
3633       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
3634       if (offset < 0)
3635         return;
3636     }
3637
3638   gtk_adjustment_set_value (tree_view->priv->vadjustment,
3639                             MAX (tree_view->priv->vadjustment->value + offset, 0.0));
3640 }
3641
3642 static gboolean
3643 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view)
3644 {
3645   GdkRectangle visible_rect;
3646   gint x;
3647   gint offset;
3648
3649   gdk_window_get_pointer (tree_view->priv->bin_window, &x, NULL, NULL);
3650
3651   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3652
3653   /* See if we are near the edge. */
3654   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
3655   if (offset > 0)
3656     {
3657       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
3658       if (offset < 0)
3659         return TRUE;
3660     }
3661   offset = offset/3;
3662
3663   gtk_adjustment_set_value (tree_view->priv->hadjustment,
3664                             MAX (tree_view->priv->hadjustment->value + offset, 0.0));
3665
3666   return TRUE;
3667
3668 }
3669
3670 static gboolean
3671 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
3672                                   GdkEventMotion *event)
3673 {
3674   GtkTreeView *tree_view = (GtkTreeView *) widget;
3675   GtkTreeViewColumn *column = tree_view->priv->drag_column;
3676   gint x, y;
3677
3678   /* Sanity Check */
3679   if ((column == NULL) ||
3680       (event->window != tree_view->priv->drag_window))
3681     return FALSE;
3682
3683   /* Handle moving the header */
3684   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
3685   x = CLAMP (x + (gint)event->x - column->drag_x, 0,
3686              MAX (tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width) - column->button->allocation.width);
3687   gdk_window_move (tree_view->priv->drag_window, x, y);
3688
3689   /* autoscroll, if needed */
3690   gtk_tree_view_horizontal_autoscroll (tree_view);
3691   /* Update the current reorder position and arrow; */
3692   gtk_tree_view_update_current_reorder (tree_view);
3693
3694   return TRUE;
3695 }
3696
3697 static void
3698 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
3699 {
3700   remove_scroll_timeout (tree_view);
3701   gtk_grab_remove (GTK_WIDGET (tree_view));
3702
3703   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
3704     {
3705       GtkTreePath *tmp_path;
3706
3707       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
3708
3709       /* The anchor path should be set to the start path */
3710       tmp_path = _gtk_tree_view_find_path (tree_view,
3711                                            tree_view->priv->rubber_band_start_tree,
3712                                            tree_view->priv->rubber_band_start_node);
3713
3714       if (tree_view->priv->anchor)
3715         gtk_tree_row_reference_free (tree_view->priv->anchor);
3716
3717       tree_view->priv->anchor =
3718         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
3719                                           tree_view->priv->model,
3720                                           tmp_path);
3721
3722       gtk_tree_path_free (tmp_path);
3723
3724       /* ... and the cursor to the end path */
3725       tmp_path = _gtk_tree_view_find_path (tree_view,
3726                                            tree_view->priv->rubber_band_end_tree,
3727                                            tree_view->priv->rubber_band_end_node);
3728       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, FALSE, FALSE);
3729       gtk_tree_path_free (tmp_path);
3730
3731       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
3732     }
3733
3734   /* Clear status variables */
3735   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
3736   tree_view->priv->rubber_band_shift = 0;
3737   tree_view->priv->rubber_band_ctrl = 0;
3738
3739   tree_view->priv->rubber_band_start_node = NULL;
3740   tree_view->priv->rubber_band_start_tree = NULL;
3741   tree_view->priv->rubber_band_end_node = NULL;
3742   tree_view->priv->rubber_band_end_tree = NULL;
3743 }
3744
3745 static void
3746 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
3747                                                  GtkRBTree   *start_tree,
3748                                                  GtkRBNode   *start_node,
3749                                                  GtkRBTree   *end_tree,
3750                                                  GtkRBNode   *end_node,
3751                                                  gboolean     select,
3752                                                  gboolean     skip_start,
3753                                                  gboolean     skip_end)
3754 {
3755   if (start_node == end_node)
3756     return;
3757
3758   /* We skip the first node and jump inside the loop */
3759   if (skip_start)
3760     goto skip_first;
3761
3762   do
3763     {
3764       /* Small optimization by assuming insensitive nodes are never
3765        * selected.
3766        */
3767       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
3768         {
3769           GtkTreePath *path;
3770           gboolean selectable;
3771
3772           path = _gtk_tree_view_find_path (tree_view, start_tree, start_node);
3773           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
3774           gtk_tree_path_free (path);
3775
3776           if (!selectable)
3777             goto node_not_selectable;
3778         }
3779
3780       if (select)
3781         {
3782           if (tree_view->priv->rubber_band_shift)
3783             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3784           else if (tree_view->priv->rubber_band_ctrl)
3785             {
3786               /* Toggle the selection state */
3787               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
3788                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3789               else
3790                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3791             }
3792           else
3793             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3794         }
3795       else
3796         {
3797           /* Mirror the above */
3798           if (tree_view->priv->rubber_band_shift)
3799             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3800           else if (tree_view->priv->rubber_band_ctrl)
3801             {
3802               /* Toggle the selection state */
3803               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
3804                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3805               else
3806                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3807             }
3808           else
3809             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3810         }
3811
3812       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
3813
3814 node_not_selectable:
3815       if (start_node == end_node)
3816         break;
3817
3818 skip_first:
3819
3820       if (start_node->children)
3821         {
3822           start_tree = start_node->children;
3823           start_node = start_tree->root;
3824           while (start_node->left != start_tree->nil)
3825             start_node = start_node->left;
3826         }
3827       else
3828         {
3829           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
3830
3831           if (!start_tree)
3832             /* Ran out of tree */
3833             break;
3834         }
3835
3836       if (skip_end && start_node == end_node)
3837         break;
3838     }
3839   while (TRUE);
3840 }
3841
3842 static void
3843 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
3844 {
3845   GtkRBTree *start_tree, *end_tree;
3846   GtkRBNode *start_node, *end_node;
3847
3848   _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);
3849   _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);
3850
3851   /* Handle the start area first */
3852   if (!tree_view->priv->rubber_band_start_node)
3853     {
3854       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3855                                                        start_tree,
3856                                                        start_node,
3857                                                        end_tree,
3858                                                        end_node,
3859                                                        TRUE,
3860                                                        FALSE,
3861                                                        FALSE);
3862     }
3863   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
3864            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
3865     {
3866       /* New node is above the old one; selection became bigger */
3867       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3868                                                        start_tree,
3869                                                        start_node,
3870                                                        tree_view->priv->rubber_band_start_tree,
3871                                                        tree_view->priv->rubber_band_start_node,
3872                                                        TRUE,
3873                                                        FALSE,
3874                                                        TRUE);
3875     }
3876   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
3877            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
3878     {
3879       /* New node is below the old one; selection became smaller */
3880       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3881                                                        tree_view->priv->rubber_band_start_tree,
3882                                                        tree_view->priv->rubber_band_start_node,
3883                                                        start_tree,
3884                                                        start_node,
3885                                                        FALSE,
3886                                                        FALSE,
3887                                                        TRUE);
3888     }
3889
3890   tree_view->priv->rubber_band_start_tree = start_tree;
3891   tree_view->priv->rubber_band_start_node = start_node;
3892
3893   /* Next, handle the end area */
3894   if (!tree_view->priv->rubber_band_end_node)
3895     {
3896       /* In the event this happens, start_node was also NULL; this case is
3897        * handled above.
3898        */
3899     }
3900   else if (!end_node)
3901     {
3902       /* Find the last node in the tree */
3903       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
3904                                &end_tree, &end_node);
3905
3906       /* Selection reached end of the tree */
3907       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3908                                                        tree_view->priv->rubber_band_end_tree,
3909                                                        tree_view->priv->rubber_band_end_node,
3910                                                        end_tree,
3911                                                        end_node,
3912                                                        TRUE,
3913                                                        TRUE,
3914                                                        FALSE);
3915     }
3916   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
3917            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
3918     {
3919       /* New node is below the old one; selection became bigger */
3920       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3921                                                        tree_view->priv->rubber_band_end_tree,
3922                                                        tree_view->priv->rubber_band_end_node,
3923                                                        end_tree,
3924                                                        end_node,
3925                                                        TRUE,
3926                                                        TRUE,
3927                                                        FALSE);
3928     }
3929   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
3930            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
3931     {
3932       /* New node is above the old one; selection became smaller */
3933       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3934                                                        end_tree,
3935                                                        end_node,
3936                                                        tree_view->priv->rubber_band_end_tree,
3937                                                        tree_view->priv->rubber_band_end_node,
3938                                                        FALSE,
3939                                                        TRUE,
3940                                                        FALSE);
3941     }
3942
3943   tree_view->priv->rubber_band_end_tree = end_tree;
3944   tree_view->priv->rubber_band_end_node = end_node;
3945 }
3946
3947 static void
3948 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
3949 {
3950   gint x, y;
3951   GdkRectangle old_area;
3952   GdkRectangle new_area;
3953   GdkRectangle common;
3954   GdkRegion *invalid_region;
3955
3956   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
3957   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
3958   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
3959   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
3960
3961   gdk_window_get_pointer (tree_view->priv->bin_window, &x, &y, NULL);
3962
3963   x = MAX (x, 0);
3964   y = MAX (y, 0) + tree_view->priv->dy;
3965
3966   new_area.x = MIN (tree_view->priv->press_start_x, x);
3967   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
3968   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
3969   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
3970
3971   invalid_region = gdk_region_rectangle (&old_area);
3972   gdk_region_union_with_rect (invalid_region, &new_area);
3973
3974   gdk_rectangle_intersect (&old_area, &new_area, &common);
3975   if (common.width > 2 && common.height > 2)
3976     {
3977       GdkRegion *common_region;
3978
3979       /* make sure the border is invalidated */
3980       common.x += 1;
3981       common.y += 1;
3982       common.width -= 2;
3983       common.height -= 2;
3984
3985       common_region = gdk_region_rectangle (&common);
3986
3987       gdk_region_subtract (invalid_region, common_region);
3988       gdk_region_destroy (common_region);
3989     }
3990
3991   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
3992
3993   gdk_region_destroy (invalid_region);
3994
3995   tree_view->priv->rubber_band_x = x;
3996   tree_view->priv->rubber_band_y = y;
3997
3998   gtk_tree_view_update_rubber_band_selection (tree_view);
3999 }
4000
4001 static void
4002 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4003                                 GdkRectangle *area)
4004 {
4005   cairo_t *cr;
4006   GdkRectangle rect;
4007   GdkRectangle rubber_rect;
4008
4009   rubber_rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4010   rubber_rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4011   rubber_rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4012   rubber_rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4013
4014   if (!gdk_rectangle_intersect (&rubber_rect, area, &rect))
4015     return;
4016
4017   cr = gdk_cairo_create (tree_view->priv->bin_window);
4018   cairo_set_line_width (cr, 1.0);
4019
4020   cairo_set_source_rgba (cr,
4021                          GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].red / 65535.,
4022                          GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].green / 65535.,
4023                          GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].blue / 65535.,
4024                          .25);
4025
4026   gdk_cairo_rectangle (cr, &rect);
4027   cairo_clip (cr);
4028   cairo_paint (cr);
4029
4030   cairo_set_source_rgb (cr,
4031                         GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].red / 65535.,
4032                         GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].green / 65535.,
4033                         GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].blue / 65535.);
4034
4035   cairo_rectangle (cr,
4036                    rubber_rect.x + 0.5, rubber_rect.y + 0.5,
4037                    rubber_rect.width - 1, rubber_rect.height - 1);
4038   cairo_stroke (cr);
4039
4040   cairo_destroy (cr);
4041 }
4042
4043 static gboolean
4044 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4045                                  GdkEventMotion *event)
4046 {
4047   GtkTreeView *tree_view;
4048   GtkRBTree *tree;
4049   GtkRBNode *node;
4050   gint new_y;
4051
4052   tree_view = (GtkTreeView *) widget;
4053
4054   if (tree_view->priv->tree == NULL)
4055     return FALSE;
4056
4057   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4058     {
4059       gtk_grab_add (GTK_WIDGET (tree_view));
4060       gtk_tree_view_update_rubber_band (tree_view);
4061
4062       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4063     }
4064   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4065     {
4066       gtk_tree_view_update_rubber_band (tree_view);
4067
4068       add_scroll_timeout (tree_view);
4069     }
4070
4071   /* only check for an initiated drag when a button is pressed */
4072   if (tree_view->priv->pressed_button >= 0
4073       && !tree_view->priv->rubber_band_status)
4074     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4075
4076   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4077   if (new_y < 0)
4078     new_y = 0;
4079
4080   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4081
4082   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4083   if ((tree_view->priv->button_pressed_node != NULL) &&
4084       (tree_view->priv->button_pressed_node != node))
4085     node = NULL;
4086
4087   prelight_or_select (tree_view, tree, node, event->x, event->y);
4088
4089   return TRUE;
4090 }
4091
4092 static gboolean
4093 gtk_tree_view_motion (GtkWidget      *widget,
4094                       GdkEventMotion *event)
4095 {
4096   GtkTreeView *tree_view;
4097
4098   tree_view = (GtkTreeView *) widget;
4099
4100   /* Resizing a column */
4101   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
4102     return gtk_tree_view_motion_resize_column (widget, event);
4103
4104   /* Drag column */
4105   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
4106     return gtk_tree_view_motion_drag_column (widget, event);
4107
4108   /* Sanity check it */
4109   if (event->window == tree_view->priv->bin_window)
4110     return gtk_tree_view_motion_bin_window (widget, event);
4111
4112   return FALSE;
4113 }
4114
4115 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4116  * the tree is empty.
4117  */
4118 static void
4119 invalidate_empty_focus (GtkTreeView *tree_view)
4120 {
4121   GdkRectangle area;
4122
4123   if (!GTK_WIDGET_HAS_FOCUS (tree_view))
4124     return;
4125
4126   area.x = 0;
4127   area.y = 0;
4128   gdk_drawable_get_size (tree_view->priv->bin_window, &area.width, &area.height);
4129   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4130 }
4131
4132 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4133  * is empty.
4134  */
4135 static void
4136 draw_empty_focus (GtkTreeView *tree_view, GdkRectangle *clip_area)
4137 {
4138   gint w, h;
4139
4140   if (!GTK_WIDGET_HAS_FOCUS (tree_view))
4141     return;
4142
4143   gdk_drawable_get_size (tree_view->priv->bin_window, &w, &h);
4144
4145   w -= 2;
4146   h -= 2;
4147
4148   if (w > 0 && h > 0)
4149     gtk_paint_focus (GTK_WIDGET (tree_view)->style,
4150                      tree_view->priv->bin_window,
4151                      GTK_WIDGET_STATE (tree_view),
4152                      clip_area,
4153                      GTK_WIDGET (tree_view),
4154                      NULL,
4155                      1, 1, w, h);
4156 }
4157
4158 static void
4159 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4160                                GdkEventExpose *event,
4161                                gint            n_visible_columns)
4162 {
4163   GList *list = tree_view->priv->columns;
4164   gint i = 0;
4165   gint current_x = 0;
4166
4167   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4168       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4169     return;
4170
4171   /* Only draw the lines for visible rows and columns */
4172   for (list = tree_view->priv->columns; list; list = list->next, i++)
4173     {
4174       GtkTreeViewColumn *column = list->data;
4175
4176       /* We don't want a line for the last column */
4177       if (i == n_visible_columns - 1)
4178         break;
4179
4180       if (! column->visible)
4181         continue;
4182
4183       current_x += column->width;
4184
4185       gdk_draw_line (event->window,
4186                      tree_view->priv->grid_line_gc,
4187                      current_x - 1, 0,
4188                      current_x - 1, tree_view->priv->height);
4189     }
4190 }
4191
4192 /* Warning: Very scary function.
4193  * Modify at your own risk
4194  *
4195  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4196  * FIXME: It's not...
4197  */
4198 static gboolean
4199 gtk_tree_view_bin_expose (GtkWidget      *widget,
4200                           GdkEventExpose *event)
4201 {
4202   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4203   GtkTreePath *path;
4204   GtkRBTree *tree;
4205   GList *list;
4206   GtkRBNode *node;
4207   GtkRBNode *cursor = NULL;
4208   GtkRBTree *cursor_tree = NULL;
4209   GtkRBNode *drag_highlight = NULL;
4210   GtkRBTree *drag_highlight_tree = NULL;
4211   GtkTreeIter iter;
4212   gint new_y;
4213   gint y_offset, cell_offset;
4214   gint max_height;
4215   gint depth;
4216   GdkRectangle background_area;
4217   GdkRectangle cell_area;
4218   guint flags;
4219   gint highlight_x;
4220   gint expander_cell_width;
4221   gint bin_window_width;
4222   gint bin_window_height;
4223   GtkTreePath *cursor_path;
4224   GtkTreePath *drag_dest_path;
4225   GList *first_column, *last_column;
4226   gint vertical_separator;
4227   gint horizontal_separator;
4228   gint focus_line_width;
4229   gboolean allow_rules;
4230   gboolean has_special_cell;
4231   gboolean rtl;
4232   gint n_visible_columns;
4233   gint pointer_x, pointer_y;
4234   gint grid_line_width;
4235   gboolean got_pointer = FALSE;
4236   gboolean row_ending_details;
4237   gboolean draw_vgrid_lines, draw_hgrid_lines;
4238
4239   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4240
4241   gtk_widget_style_get (widget,
4242                         "horizontal-separator", &horizontal_separator,
4243                         "vertical-separator", &vertical_separator,
4244                         "allow-rules", &allow_rules,
4245                         "focus-line-width", &focus_line_width,
4246                         "row-ending-details", &row_ending_details,
4247                         NULL);
4248
4249   if (tree_view->priv->tree == NULL)
4250     {
4251       draw_empty_focus (tree_view, &event->area);
4252       return TRUE;
4253     }
4254
4255   /* clip event->area to the visible area */
4256   if (event->area.height < 0)
4257     return TRUE;
4258
4259   validate_visible_area (tree_view);
4260
4261   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, event->area.y);
4262
4263   if (new_y < 0)
4264     new_y = 0;
4265   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4266   gdk_drawable_get_size (tree_view->priv->bin_window,
4267                          &bin_window_width, &bin_window_height);
4268
4269   if (tree_view->priv->height < bin_window_height)
4270     {
4271       gtk_paint_flat_box (widget->style,
4272                           event->window,
4273                           widget->state,
4274                           GTK_SHADOW_NONE,
4275                           &event->area,
4276                           widget,
4277                           "cell_even",
4278                           0, tree_view->priv->height,
4279                           bin_window_width,
4280                           bin_window_height - tree_view->priv->height);
4281     }
4282
4283   if (node == NULL)
4284     return TRUE;
4285
4286   /* find the path for the node */
4287   path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
4288                                    tree,
4289                                    node);
4290   gtk_tree_model_get_iter (tree_view->priv->model,
4291                            &iter,
4292                            path);
4293   depth = gtk_tree_path_get_depth (path);
4294   gtk_tree_path_free (path);
4295
4296   cursor_path = NULL;
4297   drag_dest_path = NULL;
4298
4299   if (tree_view->priv->cursor)
4300     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
4301
4302   if (cursor_path)
4303     _gtk_tree_view_find_node (tree_view, cursor_path,
4304                               &cursor_tree, &cursor);
4305
4306   if (tree_view->priv->drag_dest_row)
4307     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4308
4309   if (drag_dest_path)
4310     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4311                               &drag_highlight_tree, &drag_highlight);
4312
4313   draw_vgrid_lines =
4314     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4315     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4316   draw_hgrid_lines =
4317     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4318     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4319
4320   if (draw_vgrid_lines || draw_hgrid_lines)
4321     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4322
4323   n_visible_columns = 0;
4324   for (list = tree_view->priv->columns; list; list = list->next)
4325     {
4326       if (! GTK_TREE_VIEW_COLUMN (list->data)->visible)
4327         continue;
4328       n_visible_columns ++;
4329     }
4330
4331   /* Find the last column */
4332   for (last_column = g_list_last (tree_view->priv->columns);
4333        last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible);
4334        last_column = last_column->prev)
4335     ;
4336
4337   /* and the first */
4338   for (first_column = g_list_first (tree_view->priv->columns);
4339        first_column && !(GTK_TREE_VIEW_COLUMN (first_column->data)->visible);
4340        first_column = first_column->next)
4341     ;
4342
4343   /* Actually process the expose event.  To do this, we want to
4344    * start at the first node of the event, and walk the tree in
4345    * order, drawing each successive node.
4346    */
4347
4348   do
4349     {
4350       gboolean parity;
4351       gboolean is_separator = FALSE;
4352       gboolean is_first = FALSE;
4353       gboolean is_last = FALSE;
4354
4355       is_separator = row_is_separator (tree_view, &iter, NULL);
4356
4357       max_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
4358
4359       cell_offset = 0;
4360       highlight_x = 0; /* should match x coord of first cell */
4361       expander_cell_width = 0;
4362
4363       background_area.y = y_offset + event->area.y;
4364       background_area.height = max_height;
4365
4366       flags = 0;
4367
4368       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4369         flags |= GTK_CELL_RENDERER_PRELIT;
4370
4371       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4372         flags |= GTK_CELL_RENDERER_SELECTED;
4373
4374       parity = _gtk_rbtree_node_find_parity (tree, node);
4375
4376       /* we *need* to set cell data on all cells before the call
4377        * to _has_special_cell, else _has_special_cell() does not
4378        * return a correct value.
4379        */
4380       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4381            list;
4382            list = (rtl ? list->prev : list->next))
4383         {
4384           GtkTreeViewColumn *column = list->data;
4385           gtk_tree_view_column_cell_set_cell_data (column,
4386                                                    tree_view->priv->model,
4387                                                    &iter,
4388                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4389                                                    node->children?TRUE:FALSE);
4390         }
4391
4392       has_special_cell = gtk_tree_view_has_special_cell (tree_view);
4393
4394       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4395            list;
4396            list = (rtl ? list->prev : list->next))
4397         {
4398           GtkTreeViewColumn *column = list->data;
4399           const gchar *detail = NULL;
4400           GtkStateType state;
4401
4402           if (!column->visible)
4403             continue;
4404
4405           if (cell_offset > event->area.x + event->area.width ||
4406               cell_offset + column->width < event->area.x)
4407             {
4408               cell_offset += column->width;
4409               continue;
4410             }
4411
4412           if (column->show_sort_indicator)
4413             flags |= GTK_CELL_RENDERER_SORTED;
4414           else
4415             flags &= ~GTK_CELL_RENDERER_SORTED;
4416
4417           if (cursor == node)
4418             flags |= GTK_CELL_RENDERER_FOCUSED;
4419           else
4420             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4421
4422           background_area.x = cell_offset;
4423           background_area.width = column->width;
4424
4425           cell_area = background_area;
4426           cell_area.y += vertical_separator / 2;
4427           cell_area.x += horizontal_separator / 2;
4428           cell_area.height -= vertical_separator;
4429           cell_area.width -= horizontal_separator;
4430
4431           if (draw_vgrid_lines)
4432             {
4433               if (list == first_column)
4434                 {
4435                   cell_area.width -= grid_line_width / 2;
4436                 }
4437               else if (list == last_column)
4438                 {
4439                   cell_area.x += grid_line_width / 2;
4440                   cell_area.width -= grid_line_width / 2;
4441                 }
4442               else
4443                 {
4444                   cell_area.x += grid_line_width / 2;
4445                   cell_area.width -= grid_line_width;
4446                 }
4447             }
4448
4449           if (draw_hgrid_lines)
4450             {
4451               cell_area.y += grid_line_width / 2;
4452               cell_area.height -= grid_line_width;
4453             }
4454
4455           if (gdk_region_rect_in (event->region, &background_area) == GDK_OVERLAP_RECTANGLE_OUT)
4456             {
4457               cell_offset += column->width;
4458               continue;
4459             }
4460
4461           gtk_tree_view_column_cell_set_cell_data (column,
4462                                                    tree_view->priv->model,
4463                                                    &iter,
4464                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4465                                                    node->children?TRUE:FALSE);
4466
4467           /* Select the detail for drawing the cell.  relevant
4468            * factors are parity, sortedness, and whether to
4469            * display rules.
4470            */
4471           if (allow_rules && tree_view->priv->has_rules)
4472             {
4473               if ((flags & GTK_CELL_RENDERER_SORTED) &&
4474                   n_visible_columns >= 3)
4475                 {
4476                   if (parity)
4477                     detail = "cell_odd_ruled_sorted";
4478                   else
4479                     detail = "cell_even_ruled_sorted";
4480                 }
4481               else
4482                 {
4483                   if (parity)
4484                     detail = "cell_odd_ruled";
4485                   else
4486                     detail = "cell_even_ruled";
4487                 }
4488             }
4489           else
4490             {
4491               if ((flags & GTK_CELL_RENDERER_SORTED) &&
4492                   n_visible_columns >= 3)
4493                 {
4494                   if (parity)
4495                     detail = "cell_odd_sorted";
4496                   else
4497                     detail = "cell_even_sorted";
4498                 }
4499               else
4500                 {
4501                   if (parity)
4502                     detail = "cell_odd";
4503                   else
4504                     detail = "cell_even";
4505                 }
4506             }
4507
4508           g_assert (detail);
4509
4510           if (widget->state == GTK_STATE_INSENSITIVE)
4511             state = GTK_STATE_INSENSITIVE;
4512           else if (flags & GTK_CELL_RENDERER_SELECTED)
4513             state = GTK_STATE_SELECTED;
4514           else
4515             state = GTK_STATE_NORMAL;
4516
4517           /* Draw background */
4518           if (row_ending_details)
4519             {
4520               char new_detail[128];
4521
4522               is_first = (rtl ? !list->next : !list->prev);
4523               is_last = (rtl ? !list->prev : !list->next);
4524
4525               /* (I don't like the snprintfs either, but couldn't find a
4526                * less messy way).
4527                */
4528               if (is_first && is_last)
4529                 g_snprintf (new_detail, 127, "%s", detail);
4530               else if (is_first)
4531                 g_snprintf (new_detail, 127, "%s_start", detail);
4532               else if (is_last)
4533                 g_snprintf (new_detail, 127, "%s_end", detail);
4534               else
4535                 g_snprintf (new_detail, 128, "%s_middle", detail);
4536
4537               gtk_paint_flat_box (widget->style,
4538                                   event->window,
4539                                   state,
4540                                   GTK_SHADOW_NONE,
4541                                   &event->area,
4542                                   widget,
4543                                   new_detail,
4544                                   background_area.x,
4545                                   background_area.y,
4546                                   background_area.width,
4547                                   background_area.height);
4548             }
4549           else
4550             {
4551               gtk_paint_flat_box (widget->style,
4552                                   event->window,
4553                                   state,
4554                                   GTK_SHADOW_NONE,
4555                                   &event->area,
4556                                   widget,
4557                                   detail,
4558                                   background_area.x,
4559                                   background_area.y,
4560                                   background_area.width,
4561                                   background_area.height);
4562             }
4563
4564           if (draw_hgrid_lines)
4565             {
4566               if (background_area.y > 0)
4567                 gdk_draw_line (event->window,
4568                                tree_view->priv->grid_line_gc,
4569                                background_area.x, background_area.y,
4570                                background_area.x + background_area.width,
4571                                background_area.y);
4572
4573               if (y_offset + max_height >= event->area.height)
4574                 gdk_draw_line (event->window,
4575                                tree_view->priv->grid_line_gc,
4576                                background_area.x, background_area.y + max_height,
4577                                background_area.x + background_area.width,
4578                                background_area.y + max_height);
4579             }
4580
4581           if (gtk_tree_view_is_expander_column (tree_view, column) &&
4582               tree_view->priv->tree_lines_enabled)
4583             {
4584               gint x = background_area.x;
4585               gint mult = rtl ? -1 : 1;
4586               gint y0 = background_area.y;
4587               gint y1 = background_area.y + background_area.height/2;
4588               gint y2 = background_area.y + background_area.height;
4589
4590               if (rtl)
4591                 x += background_area.width - 1;
4592
4593               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
4594                   && depth > 1)
4595                 {
4596                   gdk_draw_line (event->window,
4597                                  tree_view->priv->tree_line_gc,
4598                                  x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4599                                  y1,
4600                                  x + tree_view->priv->expander_size * (depth - 1.1) * mult,
4601                                  y1);
4602                 }
4603               else if (depth > 1)
4604                 {
4605                   gdk_draw_line (event->window,
4606                                  tree_view->priv->tree_line_gc,
4607                                  x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4608                                  y1,
4609                                  x + tree_view->priv->expander_size * (depth - 0.5) * mult,
4610                                  y1);
4611                 }
4612
4613               if (depth > 1)
4614                 {
4615                   gint i;
4616                   GtkRBNode *tmp_node;
4617                   GtkRBTree *tmp_tree;
4618
4619                   if (!_gtk_rbtree_next (tree, node))
4620                     gdk_draw_line (event->window,
4621                                    tree_view->priv->tree_line_gc,
4622                                    x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4623                                    y0,
4624                                    x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4625                                    y1);
4626                   else
4627                     gdk_draw_line (event->window,
4628                                    tree_view->priv->tree_line_gc,
4629                                    x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4630                                    y0,
4631                                    x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4632                                    y2);
4633
4634                   tmp_node = tree->parent_node;
4635                   tmp_tree = tree->parent_tree;
4636
4637                   for (i = depth - 2; i > 0; i--)
4638                     {
4639                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
4640                         gdk_draw_line (event->window,
4641                                        tree_view->priv->tree_line_gc,
4642                                        x + tree_view->priv->expander_size * (i - 0.5) * mult,
4643                                        y0,
4644                                        x + tree_view->priv->expander_size * (i - 0.5) * mult,
4645                                        y2);
4646
4647                       tmp_node = tmp_tree->parent_node;
4648                       tmp_tree = tmp_tree->parent_tree;
4649                     }
4650                 }
4651             }
4652
4653           if (gtk_tree_view_is_expander_column (tree_view, column))
4654             {
4655               if (!rtl)
4656                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
4657               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
4658
4659               if (TREE_VIEW_DRAW_EXPANDERS(tree_view))
4660                 {
4661                   if (!rtl)
4662                     cell_area.x += depth * tree_view->priv->expander_size;
4663                   cell_area.width -= depth * tree_view->priv->expander_size;
4664                 }
4665
4666               /* If we have an expander column, the highlight underline
4667                * starts with that column, so that it indicates which
4668                * level of the tree we're dropping at.
4669                */
4670               highlight_x = cell_area.x;
4671               expander_cell_width = cell_area.width;
4672
4673               if (is_separator)
4674                 gtk_paint_hline (widget->style,
4675                                  event->window,
4676                                  state,
4677                                  &cell_area,
4678                                  widget,
4679                                  NULL,
4680                                  cell_area.x,
4681                                  cell_area.x + cell_area.width,
4682                                  cell_area.y + cell_area.height / 2);
4683               else
4684                 _gtk_tree_view_column_cell_render (column,
4685                                                    event->window,
4686                                                    &background_area,
4687                                                    &cell_area,
4688                                                    &event->area,
4689                                                    flags);
4690               if (TREE_VIEW_DRAW_EXPANDERS(tree_view)
4691                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
4692                 {
4693                   if (!got_pointer)
4694                     {
4695                       gdk_window_get_pointer (tree_view->priv->bin_window,
4696                                               &pointer_x, &pointer_y, NULL);
4697                       got_pointer = TRUE;
4698                     }
4699
4700                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
4701                                             tree,
4702                                             node,
4703                                             pointer_x, pointer_y);
4704                 }
4705             }
4706           else
4707             {
4708               if (is_separator)
4709                 gtk_paint_hline (widget->style,
4710                                  event->window,
4711                                  state,
4712                                  &cell_area,
4713                                  widget,
4714                                  NULL,
4715                                  cell_area.x,
4716                                  cell_area.x + cell_area.width,
4717                                  cell_area.y + cell_area.height / 2);
4718               else
4719                 _gtk_tree_view_column_cell_render (column,
4720                                                    event->window,
4721                                                    &background_area,
4722                                                    &cell_area,
4723                                                    &event->area,
4724                                                    flags);
4725             }
4726           if (node == cursor && has_special_cell &&
4727               ((column == tree_view->priv->focus_column &&
4728                 GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) &&
4729                 GTK_WIDGET_HAS_FOCUS (widget)) ||
4730                (column == tree_view->priv->edited_column)))
4731             {
4732               _gtk_tree_view_column_cell_draw_focus (column,
4733                                                      event->window,
4734                                                      &background_area,
4735                                                      &cell_area,
4736                                                      &event->area,
4737                                                      flags);
4738             }
4739           cell_offset += column->width;
4740         }
4741
4742       if (node == drag_highlight)
4743         {
4744           /* Draw indicator for the drop
4745            */
4746           gint highlight_y = -1;
4747           GtkRBTree *tree = NULL;
4748           GtkRBNode *node = NULL;
4749           gint width;
4750
4751           switch (tree_view->priv->drag_dest_pos)
4752             {
4753             case GTK_TREE_VIEW_DROP_BEFORE:
4754               highlight_y = background_area.y - 1;
4755               if (highlight_y < 0)
4756                       highlight_y = 0;
4757               break;
4758
4759             case GTK_TREE_VIEW_DROP_AFTER:
4760               highlight_y = background_area.y + background_area.height - 1;
4761               break;
4762
4763             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
4764             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
4765               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
4766
4767               if (tree == NULL)
4768                 break;
4769               gdk_drawable_get_size (tree_view->priv->bin_window,
4770                                      &width, NULL);
4771
4772               if (row_ending_details)
4773                 gtk_paint_focus (widget->style,
4774                                  tree_view->priv->bin_window,
4775                                  GTK_WIDGET_STATE (widget),
4776                                  &event->area,
4777                                  widget,
4778                                  (is_first
4779                                   ? (is_last ? "treeview-drop-indicator" : "treeview-drop-indicator-left" )
4780                                   : (is_last ? "treeview-drop-indicator-right" : "tree-view-drop-indicator-middle" )),
4781                                  0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node)
4782                                  - focus_line_width / 2,
4783                                  width, ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node))
4784                                - focus_line_width + 1);
4785               else
4786                 gtk_paint_focus (widget->style,
4787                                  tree_view->priv->bin_window,
4788                                  GTK_WIDGET_STATE (widget),
4789                                  &event->area,
4790                                  widget,
4791                                  "treeview-drop-indicator",
4792                                  0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node)
4793                                  - focus_line_width / 2,
4794                                  width, ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node))
4795                                  - focus_line_width + 1);
4796               break;
4797             }
4798
4799           if (highlight_y >= 0)
4800             {
4801               gdk_draw_line (event->window,
4802                              widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
4803                              rtl ? highlight_x + expander_cell_width : highlight_x,
4804                              highlight_y,
4805                              rtl ? 0 : bin_window_width,
4806                              highlight_y);
4807             }
4808         }
4809
4810       /* draw the big row-spanning focus rectangle, if needed */
4811       if (!has_special_cell && node == cursor &&
4812           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) &&
4813           GTK_WIDGET_HAS_FOCUS (widget))
4814         {
4815           gint tmp_y, tmp_height;
4816           gint width;
4817           GtkStateType focus_rect_state;
4818
4819           focus_rect_state =
4820             flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
4821             (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
4822              (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE :
4823               GTK_STATE_NORMAL));
4824
4825           gdk_drawable_get_size (tree_view->priv->bin_window,
4826                                  &width, NULL);
4827
4828           if (draw_hgrid_lines)
4829             {
4830               tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node) + grid_line_width / 2;
4831               tmp_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)) - grid_line_width;
4832             }
4833           else
4834             {
4835               tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
4836               tmp_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
4837             }
4838
4839           if (row_ending_details)
4840             gtk_paint_focus (widget->style,
4841                              tree_view->priv->bin_window,
4842                              focus_rect_state,
4843                              &event->area,
4844                              widget,
4845                              (is_first
4846                               ? (is_last ? "treeview" : "treeview-left" )
4847                               : (is_last ? "treeview-right" : "treeview-middle" )),
4848                              0, tmp_y,
4849                              width, tmp_height);
4850           else
4851             gtk_paint_focus (widget->style,
4852                              tree_view->priv->bin_window,
4853                              focus_rect_state,
4854                              &event->area,
4855                              widget,
4856                              "treeview",
4857                              0, tmp_y,
4858                              width, tmp_height);
4859         }
4860
4861       y_offset += max_height;
4862       if (node->children)
4863         {
4864           GtkTreeIter parent = iter;
4865           gboolean has_child;
4866
4867           tree = node->children;
4868           node = tree->root;
4869
4870           g_assert (node != tree->nil);
4871
4872           while (node->left != tree->nil)
4873             node = node->left;
4874           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
4875                                                     &iter,
4876                                                     &parent);
4877           depth++;
4878
4879           /* Sanity Check! */
4880           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
4881         }
4882       else
4883         {
4884           gboolean done = FALSE;
4885
4886           do
4887             {
4888               node = _gtk_rbtree_next (tree, node);
4889               if (node != NULL)
4890                 {
4891                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
4892                   done = TRUE;
4893
4894                   /* Sanity Check! */
4895                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
4896                 }
4897               else
4898                 {
4899                   GtkTreeIter parent_iter = iter;
4900                   gboolean has_parent;
4901
4902                   node = tree->parent_node;
4903                   tree = tree->parent_tree;
4904                   if (tree == NULL)
4905                     /* we should go to done to free some memory */
4906                     goto done;
4907                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
4908                                                            &iter,
4909                                                            &parent_iter);
4910                   depth--;
4911
4912                   /* Sanity check */
4913                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
4914                 }
4915             }
4916           while (!done);
4917         }
4918     }
4919   while (y_offset < event->area.height);
4920
4921 done:
4922   gtk_tree_view_draw_grid_lines (tree_view, event, n_visible_columns);
4923
4924  if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4925    {
4926      GdkRectangle *rectangles;
4927      gint n_rectangles;
4928
4929      gdk_region_get_rectangles (event->region,
4930                                 &rectangles,
4931                                 &n_rectangles);
4932
4933      while (n_rectangles--)
4934        gtk_tree_view_paint_rubber_band (tree_view, &rectangles[n_rectangles]);
4935
4936      g_free (rectangles);
4937    }
4938
4939   if (cursor_path)
4940     gtk_tree_path_free (cursor_path);
4941
4942   if (drag_dest_path)
4943     gtk_tree_path_free (drag_dest_path);
4944
4945   return FALSE;
4946 }
4947
4948 static gboolean
4949 gtk_tree_view_expose (GtkWidget      *widget,
4950                       GdkEventExpose *event)
4951 {
4952   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4953
4954   if (event->window == tree_view->priv->bin_window)
4955     {
4956       gboolean retval;
4957       GList *tmp_list;
4958
4959       retval = gtk_tree_view_bin_expose (widget, event);
4960
4961       /* We can't just chain up to Container::expose as it will try to send the
4962        * event to the headers, so we handle propagating it to our children
4963        * (eg. widgets being edited) ourselves.
4964        */
4965       tmp_list = tree_view->priv->children;
4966       while (tmp_list)
4967         {
4968           GtkTreeViewChild *child = tmp_list->data;
4969           tmp_list = tmp_list->next;
4970
4971           gtk_container_propagate_expose (GTK_CONTAINER (tree_view), child->widget, event);
4972         }
4973
4974       return retval;
4975     }
4976
4977   else if (event->window == tree_view->priv->header_window)
4978     {
4979       GList *list;
4980
4981       for (list = tree_view->priv->columns; list != NULL; list = list->next)
4982         {
4983           GtkTreeViewColumn *column = list->data;
4984
4985           if (column == tree_view->priv->drag_column)
4986             continue;
4987
4988           if (column->visible)
4989             gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
4990                                             column->button,
4991                                             event);
4992         }
4993     }
4994   else if (event->window == tree_view->priv->drag_window)
4995     {
4996       gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
4997                                       tree_view->priv->drag_column->button,
4998                                       event);
4999     }
5000   return TRUE;
5001 }
5002
5003 enum
5004 {
5005   DROP_HOME,
5006   DROP_RIGHT,
5007   DROP_LEFT,
5008   DROP_END
5009 };
5010
5011 /* returns 0x1 when no column has been found -- yes it's hackish */
5012 static GtkTreeViewColumn *
5013 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5014                                GtkTreeViewColumn *column,
5015                                gint               drop_position)
5016 {
5017   GtkTreeViewColumn *left_column = NULL;
5018   GtkTreeViewColumn *cur_column = NULL;
5019   GList *tmp_list;
5020
5021   if (!column->reorderable)
5022     return (GtkTreeViewColumn *)0x1;
5023
5024   switch (drop_position)
5025     {
5026       case DROP_HOME:
5027         /* find first column where we can drop */
5028         tmp_list = tree_view->priv->columns;
5029         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5030           return (GtkTreeViewColumn *)0x1;
5031
5032         while (tmp_list)
5033           {
5034             g_assert (tmp_list);
5035
5036             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5037             tmp_list = tmp_list->next;
5038
5039             if (left_column && left_column->visible == FALSE)
5040               continue;
5041
5042             if (!tree_view->priv->column_drop_func)
5043               return left_column;
5044
5045             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5046               {
5047                 left_column = cur_column;
5048                 continue;
5049               }
5050
5051             return left_column;
5052           }
5053
5054         if (!tree_view->priv->column_drop_func)
5055           return left_column;
5056
5057         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5058           return left_column;
5059         else
5060           return (GtkTreeViewColumn *)0x1;
5061         break;
5062
5063       case DROP_RIGHT:
5064         /* find first column after column where we can drop */
5065         tmp_list = tree_view->priv->columns;
5066
5067         for (; tmp_list; tmp_list = tmp_list->next)
5068           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5069             break;
5070
5071         if (!tmp_list || !tmp_list->next)
5072           return (GtkTreeViewColumn *)0x1;
5073
5074         tmp_list = tmp_list->next;
5075         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5076         tmp_list = tmp_list->next;
5077
5078         while (tmp_list)
5079           {
5080             g_assert (tmp_list);
5081
5082             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5083             tmp_list = tmp_list->next;
5084
5085             if (left_column && left_column->visible == FALSE)
5086               {
5087                 left_column = cur_column;
5088                 if (tmp_list)
5089                   tmp_list = tmp_list->next;
5090                 continue;
5091               }
5092
5093             if (!tree_view->priv->column_drop_func)
5094               return left_column;
5095
5096             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5097               {
5098                 left_column = cur_column;
5099                 continue;
5100               }
5101
5102             return left_column;
5103           }
5104
5105         if (!tree_view->priv->column_drop_func)
5106           return left_column;
5107
5108         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5109           return left_column;
5110         else
5111           return (GtkTreeViewColumn *)0x1;
5112         break;
5113
5114       case DROP_LEFT:
5115         /* find first column before column where we can drop */
5116         tmp_list = tree_view->priv->columns;
5117
5118         for (; tmp_list; tmp_list = tmp_list->next)
5119           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5120             break;
5121
5122         if (!tmp_list || !tmp_list->prev)
5123           return (GtkTreeViewColumn *)0x1;
5124
5125         tmp_list = tmp_list->prev;
5126         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5127         tmp_list = tmp_list->prev;
5128
5129         while (tmp_list)
5130           {
5131             g_assert (tmp_list);
5132
5133             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5134
5135             if (left_column && !left_column->visible)
5136               {
5137                 /*if (!tmp_list->prev)
5138                   return (GtkTreeViewColumn *)0x1;
5139                   */
5140 /*
5141                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5142                 tmp_list = tmp_list->prev->prev;
5143                 continue;*/
5144
5145                 cur_column = left_column;
5146                 if (tmp_list)
5147                   tmp_list = tmp_list->prev;
5148                 continue;
5149               }
5150
5151             if (!tree_view->priv->column_drop_func)
5152               return left_column;
5153
5154             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5155               return left_column;
5156
5157             cur_column = left_column;
5158             tmp_list = tmp_list->prev;
5159           }
5160
5161         if (!tree_view->priv->column_drop_func)
5162           return NULL;
5163
5164         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5165           return NULL;
5166         else
5167           return (GtkTreeViewColumn *)0x1;
5168         break;
5169
5170       case DROP_END:
5171         /* same as DROP_HOME case, but doing it backwards */
5172         tmp_list = g_list_last (tree_view->priv->columns);
5173         cur_column = NULL;
5174
5175         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5176           return (GtkTreeViewColumn *)0x1;
5177
5178         while (tmp_list)
5179           {
5180             g_assert (tmp_list);
5181
5182             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5183
5184             if (left_column && !left_column->visible)
5185               {
5186                 cur_column = left_column;
5187                 tmp_list = tmp_list->prev;
5188               }
5189
5190             if (!tree_view->priv->column_drop_func)
5191               return left_column;
5192
5193             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5194               return left_column;
5195
5196             cur_column = left_column;
5197             tmp_list = tmp_list->prev;
5198           }
5199
5200         if (!tree_view->priv->column_drop_func)
5201           return NULL;
5202
5203         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5204           return NULL;
5205         else
5206           return (GtkTreeViewColumn *)0x1;
5207         break;
5208     }
5209
5210   return (GtkTreeViewColumn *)0x1;
5211 }
5212
5213 static gboolean
5214 gtk_tree_view_key_press (GtkWidget   *widget,
5215                          GdkEventKey *event)
5216 {
5217   GtkTreeView *tree_view = (GtkTreeView *) widget;
5218
5219   if (tree_view->priv->rubber_band_status)
5220     {
5221       if (event->keyval == GDK_Escape)
5222         gtk_tree_view_stop_rubber_band (tree_view);
5223
5224       return TRUE;
5225     }
5226
5227   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
5228     {
5229       if (event->keyval == GDK_Escape)
5230         {
5231           tree_view->priv->cur_reorder = NULL;
5232           gtk_tree_view_button_release_drag_column (widget, NULL);
5233         }
5234       return TRUE;
5235     }
5236
5237   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
5238     {
5239       GList *focus_column;
5240       gboolean rtl;
5241
5242       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5243
5244       for (focus_column = tree_view->priv->columns;
5245            focus_column;
5246            focus_column = focus_column->next)
5247         {
5248           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5249
5250           if (GTK_WIDGET_HAS_FOCUS (column->button))
5251             break;
5252         }
5253
5254       if (focus_column &&
5255           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5256           (event->keyval == GDK_Left || event->keyval == GDK_KP_Left
5257            || event->keyval == GDK_Right || event->keyval == GDK_KP_Right))
5258         {
5259           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5260
5261           if (!column->resizable)
5262             {
5263               gtk_widget_error_bell (widget);
5264               return TRUE;
5265             }
5266
5267           if (event->keyval == (rtl ? GDK_Right : GDK_Left)
5268               || event->keyval == (rtl ? GDK_KP_Right : GDK_KP_Left))
5269             {
5270               gint old_width = column->resized_width;
5271
5272               column->resized_width = MAX (column->resized_width,
5273                                            column->width);
5274               column->resized_width -= 2;
5275               if (column->resized_width < 0)
5276                 column->resized_width = 0;
5277
5278               if (column->min_width == -1)
5279                 column->resized_width = MAX (column->button->requisition.width,
5280                                              column->resized_width);
5281               else
5282                 column->resized_width = MAX (column->min_width,
5283                                              column->resized_width);
5284
5285               if (column->max_width != -1)
5286                 column->resized_width = MIN (column->resized_width,
5287                                              column->max_width);
5288
5289               column->use_resized_width = TRUE;
5290
5291               if (column->resized_width != old_width)
5292                 gtk_widget_queue_resize (widget);
5293               else
5294                 gtk_widget_error_bell (widget);
5295             }
5296           else if (event->keyval == (rtl ? GDK_Left : GDK_Right)
5297                    || event->keyval == (rtl ? GDK_KP_Left : GDK_KP_Right))
5298             {
5299               gint old_width = column->resized_width;
5300
5301               column->resized_width = MAX (column->resized_width,
5302                                            column->width);
5303               column->resized_width += 2;
5304
5305               if (column->max_width != -1)
5306                 column->resized_width = MIN (column->resized_width,
5307                                              column->max_width);
5308
5309               column->use_resized_width = TRUE;
5310
5311               if (column->resized_width != old_width)
5312                 gtk_widget_queue_resize (widget);
5313               else
5314                 gtk_widget_error_bell (widget);
5315             }
5316
5317           return TRUE;
5318         }
5319
5320       if (focus_column &&
5321           (event->state & GDK_MOD1_MASK) &&
5322           (event->keyval == GDK_Left || event->keyval == GDK_KP_Left
5323            || event->keyval == GDK_Right || event->keyval == GDK_KP_Right
5324            || event->keyval == GDK_Home || event->keyval == GDK_KP_Home
5325            || event->keyval == GDK_End || event->keyval == GDK_KP_End))
5326         {
5327           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5328
5329           if (event->keyval == (rtl ? GDK_Right : GDK_Left)
5330               || event->keyval == (rtl ? GDK_KP_Right : GDK_KP_Left))
5331             {
5332               GtkTreeViewColumn *col;
5333               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5334               if (col != (GtkTreeViewColumn *)0x1)
5335                 gtk_tree_view_move_column_after (tree_view, column, col);
5336               else
5337                 gtk_widget_error_bell (widget);
5338             }
5339           else if (event->keyval == (rtl ? GDK_Left : GDK_Right)
5340                    || event->keyval == (rtl ? GDK_KP_Left : GDK_KP_Right))
5341             {
5342               GtkTreeViewColumn *col;
5343               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5344               if (col != (GtkTreeViewColumn *)0x1)
5345                 gtk_tree_view_move_column_after (tree_view, column, col);
5346               else
5347                 gtk_widget_error_bell (widget);
5348             }
5349           else if (event->keyval == GDK_Home || event->keyval == GDK_KP_Home)
5350             {
5351               GtkTreeViewColumn *col;
5352               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5353               if (col != (GtkTreeViewColumn *)0x1)
5354                 gtk_tree_view_move_column_after (tree_view, column, col);
5355               else
5356                 gtk_widget_error_bell (widget);
5357             }
5358           else if (event->keyval == GDK_End || event->keyval == GDK_KP_End)
5359             {
5360               GtkTreeViewColumn *col;
5361               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
5362               if (col != (GtkTreeViewColumn *)0x1)
5363                 gtk_tree_view_move_column_after (tree_view, column, col);
5364               else
5365                 gtk_widget_error_bell (widget);
5366             }
5367
5368           return TRUE;
5369         }
5370     }
5371
5372   /* Chain up to the parent class.  It handles the keybindings. */
5373   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5374     return TRUE;
5375
5376   /* We pass the event to the search_entry.  If its text changes, then we start
5377    * the typeahead find capabilities. */
5378   if (GTK_WIDGET_HAS_FOCUS (tree_view)
5379       && tree_view->priv->enable_search
5380       && !tree_view->priv->search_custom_entry_set)
5381     {
5382       GdkEvent *new_event;
5383       char *old_text;
5384       const char *new_text;
5385       gboolean retval;
5386       GdkScreen *screen;
5387       gboolean text_modified;
5388       gulong popup_menu_id;
5389
5390       gtk_tree_view_ensure_interactive_directory (tree_view);
5391
5392       /* Make a copy of the current text */
5393       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5394       new_event = gdk_event_copy ((GdkEvent *) event);
5395       g_object_unref (((GdkEventKey *) new_event)->window);
5396       ((GdkEventKey *) new_event)->window = g_object_ref (tree_view->priv->search_window->window);
5397       gtk_widget_realize (tree_view->priv->search_window);
5398
5399       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5400                                         "popup-menu", G_CALLBACK (gtk_true),
5401                                         NULL);
5402
5403       /* Move the entry off screen */
5404       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5405       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5406                        gdk_screen_get_width (screen) + 1,
5407                        gdk_screen_get_height (screen) + 1);
5408       gtk_widget_show (tree_view->priv->search_window);
5409
5410       /* Send the event to the window.  If the preedit_changed signal is emitted
5411        * during this event, we will set priv->imcontext_changed  */
5412       tree_view->priv->imcontext_changed = FALSE;
5413       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5414       gdk_event_free (new_event);
5415       gtk_widget_hide (tree_view->priv->search_window);
5416
5417       g_signal_handler_disconnect (tree_view->priv->search_entry,
5418                                    popup_menu_id);
5419
5420       /* We check to make sure that the entry tried to handle the text, and that
5421        * the text has changed.
5422        */
5423       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5424       text_modified = strcmp (old_text, new_text) != 0;
5425       g_free (old_text);
5426       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5427           (retval && text_modified))               /* ...or the text was modified */
5428         {
5429           if (gtk_tree_view_real_start_interactive_search (tree_view, FALSE))
5430             {
5431               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5432               return TRUE;
5433             }
5434           else
5435             {
5436               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5437               return FALSE;
5438             }
5439         }
5440     }
5441
5442   return FALSE;
5443 }
5444
5445 static gboolean
5446 gtk_tree_view_key_release (GtkWidget   *widget,
5447                            GdkEventKey *event)
5448 {
5449   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5450
5451   if (tree_view->priv->rubber_band_status)
5452     return TRUE;
5453
5454   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5455 }
5456
5457 /* FIXME Is this function necessary? Can I get an enter_notify event
5458  * w/o either an expose event or a mouse motion event?
5459  */
5460 static gboolean
5461 gtk_tree_view_enter_notify (GtkWidget        *widget,
5462                             GdkEventCrossing *event)
5463 {
5464   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5465   GtkRBTree *tree;
5466   GtkRBNode *node;
5467   gint new_y;
5468
5469   /* Sanity check it */
5470   if (event->window != tree_view->priv->bin_window)
5471     return FALSE;
5472
5473   if (tree_view->priv->tree == NULL)
5474     return FALSE;
5475
5476   /* find the node internally */
5477   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5478   if (new_y < 0)
5479     new_y = 0;
5480   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5481
5482   if ((tree_view->priv->button_pressed_node == NULL) ||
5483       (tree_view->priv->button_pressed_node == node))
5484     prelight_or_select (tree_view, tree, node, event->x, event->y);
5485
5486   return TRUE;
5487 }
5488
5489 static gboolean
5490 gtk_tree_view_leave_notify (GtkWidget        *widget,
5491                             GdkEventCrossing *event)
5492 {
5493   GtkTreeView *tree_view;
5494
5495   if (event->mode == GDK_CROSSING_GRAB)
5496     return TRUE;
5497
5498   tree_view = GTK_TREE_VIEW (widget);
5499
5500   if (tree_view->priv->prelight_node)
5501     _gtk_tree_view_queue_draw_node (tree_view,
5502                                    tree_view->priv->prelight_tree,
5503                                    tree_view->priv->prelight_node,
5504                                    NULL);
5505
5506   prelight_or_select (tree_view,
5507                       NULL, NULL,
5508                       -1000, -1000); /* coords not possibly over an arrow */
5509
5510   return TRUE;
5511 }
5512
5513
5514 static gint
5515 gtk_tree_view_focus_out (GtkWidget     *widget,
5516                          GdkEventFocus *event)
5517 {
5518   GtkTreeView *tree_view;
5519
5520   tree_view = GTK_TREE_VIEW (widget);
5521
5522   gtk_widget_queue_draw (widget);
5523
5524   /* destroy interactive search dialog */
5525   if (tree_view->priv->search_window)
5526     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view);
5527
5528   return FALSE;
5529 }
5530
5531
5532 /* Incremental Reflow
5533  */
5534
5535 static void
5536 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
5537                                  GtkRBTree   *tree,
5538                                  GtkRBNode   *node)
5539 {
5540   gint y;
5541
5542   y = _gtk_rbtree_node_find_offset (tree, node)
5543     - tree_view->priv->vadjustment->value
5544     + TREE_VIEW_HEADER_HEIGHT (tree_view);
5545
5546   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
5547                               0, y,
5548                               GTK_WIDGET (tree_view)->allocation.width,
5549                               GTK_RBNODE_GET_HEIGHT (node));
5550 }
5551
5552 static gboolean
5553 node_is_visible (GtkTreeView *tree_view,
5554                  GtkRBTree   *tree,
5555                  GtkRBNode   *node)
5556 {
5557   int y;
5558   int height;
5559
5560   y = _gtk_rbtree_node_find_offset (tree, node);
5561   height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5562
5563   if (y >= tree_view->priv->vadjustment->value &&
5564       y + height <= (tree_view->priv->vadjustment->value
5565                      + tree_view->priv->vadjustment->page_size))
5566     return TRUE;
5567
5568   return FALSE;
5569 }
5570
5571 /* Returns TRUE if it updated the size
5572  */
5573 static gboolean
5574 validate_row (GtkTreeView *tree_view,
5575               GtkRBTree   *tree,
5576               GtkRBNode   *node,
5577               GtkTreeIter *iter,
5578               GtkTreePath *path)
5579 {
5580   GtkTreeViewColumn *column;
5581   GList *list, *first_column, *last_column;
5582   gint height = 0;
5583   gint horizontal_separator;
5584   gint vertical_separator;
5585   gint focus_line_width;
5586   gint depth = gtk_tree_path_get_depth (path);
5587   gboolean retval = FALSE;
5588   gboolean is_separator = FALSE;
5589   gboolean draw_vgrid_lines, draw_hgrid_lines;
5590   gint focus_pad;
5591   gint grid_line_width;
5592   gboolean wide_separators;
5593   gint separator_height;
5594
5595   /* double check the row needs validating */
5596   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
5597       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5598     return FALSE;
5599
5600   is_separator = row_is_separator (tree_view, iter, NULL);
5601
5602   gtk_widget_style_get (GTK_WIDGET (tree_view),
5603                         "focus-padding", &focus_pad,
5604                         "focus-line-width", &focus_line_width,
5605                         "horizontal-separator", &horizontal_separator,
5606                         "vertical-separator", &vertical_separator,
5607                         "grid-line-width", &grid_line_width,
5608                         "wide-separators",  &wide_separators,
5609                         "separator-height", &separator_height,
5610                         NULL);
5611
5612   draw_vgrid_lines =
5613     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
5614     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
5615   draw_hgrid_lines =
5616     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
5617     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
5618
5619   for (last_column = g_list_last (tree_view->priv->columns);
5620        last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible);
5621        last_column = last_column->prev)
5622     ;
5623
5624   for (first_column = g_list_first (tree_view->priv->columns);
5625        first_column && !(GTK_TREE_VIEW_COLUMN (first_column->data)->visible);
5626        first_column = first_column->next)
5627     ;
5628
5629   for (list = tree_view->priv->columns; list; list = list->next)
5630     {
5631       gint tmp_width;
5632       gint tmp_height;
5633
5634       column = list->data;
5635
5636       if (! column->visible)
5637         continue;
5638
5639       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) && !column->dirty)
5640         continue;
5641
5642       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
5643                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
5644                                                node->children?TRUE:FALSE);
5645       gtk_tree_view_column_cell_get_size (column,
5646                                           NULL, NULL, NULL,
5647                                           &tmp_width, &tmp_height);
5648
5649       if (!is_separator)
5650         {
5651           tmp_height += vertical_separator;
5652           height = MAX (height, tmp_height);
5653           height = MAX (height, tree_view->priv->expander_size);
5654         }
5655       else
5656         {
5657           if (wide_separators)
5658             height = separator_height + 2 * focus_pad;
5659           else
5660             height = 2 + 2 * focus_pad;
5661         }
5662
5663       if (gtk_tree_view_is_expander_column (tree_view, column))
5664         {
5665           tmp_width = tmp_width + horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
5666
5667           if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
5668             tmp_width += depth * tree_view->priv->expander_size;
5669         }
5670       else
5671         tmp_width = tmp_width + horizontal_separator;
5672
5673       if (draw_vgrid_lines)
5674         {
5675           if (list->data == first_column || list->data == last_column)
5676             tmp_width += grid_line_width / 2.0;
5677           else
5678             tmp_width += grid_line_width;
5679         }
5680
5681       if (tmp_width > column->requested_width)
5682         {
5683           retval = TRUE;
5684           column->requested_width = tmp_width;
5685         }
5686     }
5687
5688   if (draw_hgrid_lines)
5689     height += grid_line_width;
5690
5691   if (height != GTK_RBNODE_GET_HEIGHT (node))
5692     {
5693       retval = TRUE;
5694       _gtk_rbtree_node_set_height (tree, node, height);
5695     }
5696   _gtk_rbtree_node_mark_valid (tree, node);
5697   tree_view->priv->post_validation_flag = TRUE;
5698
5699   return retval;
5700 }
5701
5702
5703 static void
5704 validate_visible_area (GtkTreeView *tree_view)
5705 {
5706   GtkTreePath *path = NULL;
5707   GtkTreePath *above_path = NULL;
5708   GtkTreeIter iter;
5709   GtkRBTree *tree = NULL;
5710   GtkRBNode *node = NULL;
5711   gboolean need_redraw = FALSE;
5712   gboolean size_changed = FALSE;
5713   gint total_height;
5714   gint area_above = 0;
5715   gint area_below = 0;
5716
5717   if (tree_view->priv->tree == NULL)
5718     return;
5719
5720   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
5721       tree_view->priv->scroll_to_path == NULL)
5722     return;
5723
5724   total_height = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
5725
5726   if (total_height == 0)
5727     return;
5728
5729   /* First, we check to see if we need to scroll anywhere
5730    */
5731   if (tree_view->priv->scroll_to_path)
5732     {
5733       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
5734       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
5735         {
5736           /* we are going to scroll, and will update dy */
5737           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
5738           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
5739               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5740             {
5741               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
5742               if (validate_row (tree_view, tree, node, &iter, path))
5743                 size_changed = TRUE;
5744             }
5745
5746           if (tree_view->priv->scroll_to_use_align)
5747             {
5748               gint height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5749               area_above = (total_height - height) *
5750                 tree_view->priv->scroll_to_row_align;
5751               area_below = total_height - area_above - height;
5752               area_above = MAX (area_above, 0);
5753               area_below = MAX (area_below, 0);
5754             }
5755           else
5756             {
5757               /* two cases:
5758                * 1) row not visible
5759                * 2) row visible
5760                */
5761               gint dy;
5762               gint height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5763
5764               dy = _gtk_rbtree_node_find_offset (tree, node);
5765
5766               if (dy >= tree_view->priv->vadjustment->value &&
5767                   dy + height <= (tree_view->priv->vadjustment->value
5768                                   + tree_view->priv->vadjustment->page_size))
5769                 {
5770                   /* row visible: keep the row at the same position */
5771                   area_above = dy - tree_view->priv->vadjustment->value;
5772                   area_below = (tree_view->priv->vadjustment->value +
5773                                 tree_view->priv->vadjustment->page_size)
5774                                - dy - height;
5775                 }
5776               else
5777                 {
5778                   /* row not visible */
5779                   if (dy >= 0
5780                       && dy + height <= tree_view->priv->vadjustment->page_size)
5781                     {
5782                       /* row at the beginning -- fixed */
5783                       area_above = dy;
5784                       area_below = tree_view->priv->vadjustment->page_size
5785                                    - area_above - height;
5786                     }
5787                   else if (dy >= (tree_view->priv->vadjustment->upper -
5788                                   tree_view->priv->vadjustment->page_size))
5789                     {
5790                       /* row at the end -- fixed */
5791                       area_above = dy - (tree_view->priv->vadjustment->upper -
5792                                    tree_view->priv->vadjustment->page_size);
5793                       area_below = tree_view->priv->vadjustment->page_size -
5794                                    area_above - height;
5795
5796                       if (area_below < 0)
5797                         {
5798                           area_above = tree_view->priv->vadjustment->page_size - height;
5799                           area_below = 0;
5800                         }
5801                     }
5802                   else
5803                     {
5804                       /* row somewhere in the middle, bring it to the top
5805                        * of the view
5806                        */
5807                       area_above = 0;
5808                       area_below = total_height - height;
5809                     }
5810                 }
5811             }
5812         }
5813       else
5814         /* the scroll to isn't valid; ignore it.
5815          */
5816         {
5817           if (tree_view->priv->scroll_to_path && !path)
5818             {
5819               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
5820               tree_view->priv->scroll_to_path = NULL;
5821             }
5822           if (path)
5823             gtk_tree_path_free (path);
5824           path = NULL;
5825         }
5826     }
5827
5828   /* We didn't have a scroll_to set, so we just handle things normally
5829    */
5830   if (path == NULL)
5831     {
5832       gint offset;
5833
5834       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
5835                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
5836                                         &tree, &node);
5837       if (node == NULL)
5838         {
5839           /* In this case, nothing has been validated */
5840           path = gtk_tree_path_new_first ();
5841           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
5842         }
5843       else
5844         {
5845           path = _gtk_tree_view_find_path (tree_view, tree, node);
5846           total_height += offset;
5847         }
5848
5849       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
5850
5851       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
5852           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5853         {
5854           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
5855           if (validate_row (tree_view, tree, node, &iter, path))
5856             size_changed = TRUE;
5857         }
5858       area_above = 0;
5859       area_below = total_height - ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5860     }
5861
5862   above_path = gtk_tree_path_copy (path);
5863
5864   /* if we do not validate any row above the new top_row, we will make sure
5865    * that the row immediately above top_row has been validated. (if we do not
5866    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
5867    * when invalidated that row's height will be zero. and this will mess up
5868    * scrolling).
5869    */
5870   if (area_above == 0)
5871     {
5872       GtkRBTree *tmptree;
5873       GtkRBNode *tmpnode;
5874
5875       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
5876       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
5877
5878       if (tmpnode)
5879         {
5880           GtkTreePath *tmppath;
5881           GtkTreeIter tmpiter;
5882
5883           tmppath = _gtk_tree_view_find_path (tree_view, tmptree, tmpnode);
5884           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
5885
5886           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
5887               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
5888             {
5889               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
5890               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
5891                 size_changed = TRUE;
5892             }
5893
5894           gtk_tree_path_free (tmppath);
5895         }
5896     }
5897
5898   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
5899    * backwards is much slower then forward, as there is no iter_prev function.
5900    * We go forwards first in case we run out of tree.  Then we go backwards to
5901    * fill out the top.
5902    */
5903   while (node && area_below > 0)
5904     {
5905       if (node->children)
5906         {
5907           GtkTreeIter parent = iter;
5908           gboolean has_child;
5909
5910           tree = node->children;
5911           node = tree->root;
5912
5913           g_assert (node != tree->nil);
5914
5915           while (node->left != tree->nil)
5916             node = node->left;
5917           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
5918                                                     &iter,
5919                                                     &parent);
5920           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
5921           gtk_tree_path_down (path);
5922         }
5923       else
5924         {
5925           gboolean done = FALSE;
5926           do
5927             {
5928               node = _gtk_rbtree_next (tree, node);
5929               if (node != NULL)
5930                 {
5931                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
5932                   done = TRUE;
5933                   gtk_tree_path_next (path);
5934
5935                   /* Sanity Check! */
5936                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
5937                 }
5938               else
5939                 {
5940                   GtkTreeIter parent_iter = iter;
5941                   gboolean has_parent;
5942
5943                   node = tree->parent_node;
5944                   tree = tree->parent_tree;
5945                   if (tree == NULL)
5946                     break;
5947                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
5948                                                            &iter,
5949                                                            &parent_iter);
5950                   gtk_tree_path_up (path);
5951
5952                   /* Sanity check */
5953                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
5954                 }
5955             }
5956           while (!done);
5957         }
5958
5959       if (!node)
5960         break;
5961
5962       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
5963           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5964         {
5965           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
5966           if (validate_row (tree_view, tree, node, &iter, path))
5967               size_changed = TRUE;
5968         }
5969
5970       area_below -= ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5971     }
5972   gtk_tree_path_free (path);
5973
5974   /* If we ran out of tree, and have extra area_below left, we need to add it
5975    * to area_above */
5976   if (area_below > 0)
5977     area_above += area_below;
5978
5979   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
5980
5981   /* We walk backwards */
5982   while (area_above > 0)
5983     {
5984       _gtk_rbtree_prev_full (tree, node, &tree, &node);
5985       if (! gtk_tree_path_prev (above_path) && node != NULL)
5986         {
5987           gtk_tree_path_free (above_path);
5988           above_path = _gtk_tree_view_find_path (tree_view, tree, node);
5989         }
5990       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
5991
5992       if (node == NULL)
5993         break;
5994
5995       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
5996           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5997         {
5998           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
5999           if (validate_row (tree_view, tree, node, &iter, above_path))
6000             size_changed = TRUE;
6001         }
6002       area_above -= ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
6003     }
6004
6005   /* if we scrolled to a path, we need to set the dy here,
6006    * and sync the top row accordingly
6007    */
6008   if (tree_view->priv->scroll_to_path)
6009     {
6010       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6011       gtk_tree_view_top_row_to_dy (tree_view);
6012
6013       need_redraw = TRUE;
6014     }
6015   else if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
6016     {
6017       /* when we are not scrolling, we should never set dy to something
6018        * else than zero. we update top_row to be in sync with dy = 0.
6019        */
6020       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6021       gtk_tree_view_dy_to_top_row (tree_view);
6022     }
6023   else if (tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
6024     {
6025       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - tree_view->priv->vadjustment->page_size);
6026       gtk_tree_view_dy_to_top_row (tree_view);
6027     }
6028   else
6029     gtk_tree_view_top_row_to_dy (tree_view);
6030
6031   /* update width/height and queue a resize */
6032   if (size_changed)
6033     {
6034       GtkRequisition requisition;
6035
6036       /* We temporarily guess a size, under the assumption that it will be the
6037        * same when we get our next size_allocate.  If we don't do this, we'll be
6038        * in an inconsistent state if we call top_row_to_dy. */
6039
6040       gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
6041       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6042       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6043       gtk_adjustment_changed (tree_view->priv->hadjustment);
6044       gtk_adjustment_changed (tree_view->priv->vadjustment);
6045       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6046     }
6047
6048   if (tree_view->priv->scroll_to_path)
6049     {
6050       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6051       tree_view->priv->scroll_to_path = NULL;
6052     }
6053
6054   if (above_path)
6055     gtk_tree_path_free (above_path);
6056
6057   if (tree_view->priv->scroll_to_column)
6058     {
6059       tree_view->priv->scroll_to_column = NULL;
6060     }
6061   if (need_redraw)
6062     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6063 }
6064
6065 static void
6066 initialize_fixed_height_mode (GtkTreeView *tree_view)
6067 {
6068   if (!tree_view->priv->tree)
6069     return;
6070
6071   if (tree_view->priv->fixed_height < 0)
6072     {
6073       GtkTreeIter iter;
6074       GtkTreePath *path;
6075
6076       GtkRBTree *tree = NULL;
6077       GtkRBNode *node = NULL;
6078
6079       tree = tree_view->priv->tree;
6080       node = tree->root;
6081
6082       path = _gtk_tree_view_find_path (tree_view, tree, node);
6083       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6084
6085       validate_row (tree_view, tree, node, &iter, path);
6086
6087       gtk_tree_path_free (path);
6088
6089       tree_view->priv->fixed_height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
6090     }
6091
6092    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6093                                  tree_view->priv->fixed_height, TRUE);
6094 }
6095
6096 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6097  * the left-most uninvalidated node.  We then try walking right, validating
6098  * nodes.  Once we find a valid node, we repeat the previous process of finding
6099  * the first invalid node.
6100  */
6101
6102 static gboolean
6103 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6104 {
6105   GtkRBTree *tree = NULL;
6106   GtkRBNode *node = NULL;
6107   gboolean validated_area = FALSE;
6108   gint retval = TRUE;
6109   GtkTreePath *path = NULL;
6110   GtkTreeIter iter;
6111   gint i = 0;
6112
6113   gint prev_height = -1;
6114   gboolean fixed_height = TRUE;
6115
6116   g_assert (tree_view);
6117
6118   if (tree_view->priv->tree == NULL)
6119       return FALSE;
6120
6121   if (tree_view->priv->fixed_height_mode)
6122     {
6123       if (tree_view->priv->fixed_height < 0)
6124         initialize_fixed_height_mode (tree_view);
6125
6126       return FALSE;
6127     }
6128
6129   do
6130     {
6131       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6132         {
6133           retval = FALSE;
6134           goto done;
6135         }
6136
6137       if (path != NULL)
6138         {
6139           node = _gtk_rbtree_next (tree, node);
6140           if (node != NULL)
6141             {
6142               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6143               gtk_tree_path_next (path);
6144             }
6145           else
6146             {
6147               gtk_tree_path_free (path);
6148               path = NULL;
6149             }
6150         }
6151
6152       if (path == NULL)
6153         {
6154           tree = tree_view->priv->tree;
6155           node = tree_view->priv->tree->root;
6156
6157           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6158
6159           do
6160             {
6161               if (node->left != tree->nil &&
6162                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6163                 {
6164                   node = node->left;
6165                 }
6166               else if (node->right != tree->nil &&
6167                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6168                 {
6169                   node = node->right;
6170                 }
6171               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6172                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6173                 {
6174                   break;
6175                 }
6176               else if (node->children != NULL)
6177                 {
6178                   tree = node->children;
6179                   node = tree->root;
6180                 }
6181               else
6182                 /* RBTree corruption!  All bad */
6183                 g_assert_not_reached ();
6184             }
6185           while (TRUE);
6186           path = _gtk_tree_view_find_path (tree_view, tree, node);
6187           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6188         }
6189
6190       validated_area = validate_row (tree_view, tree, node, &iter, path) ||
6191                        validated_area;
6192
6193       if (!tree_view->priv->fixed_height_check)
6194         {
6195           gint height;
6196
6197           height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
6198           if (prev_height < 0)
6199             prev_height = height;
6200           else if (prev_height != height)
6201             fixed_height = FALSE;
6202         }
6203
6204       i++;
6205     }
6206   while (i < GTK_TREE_VIEW_NUM_ROWS_PER_IDLE);
6207
6208   if (!tree_view->priv->fixed_height_check)
6209    {
6210      if (fixed_height)
6211        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6212
6213      tree_view->priv->fixed_height_check = 1;
6214    }
6215
6216  done:
6217   if (validated_area)
6218     {
6219       GtkRequisition requisition;
6220       /* We temporarily guess a size, under the assumption that it will be the
6221        * same when we get our next size_allocate.  If we don't do this, we'll be
6222        * in an inconsistent state when we call top_row_to_dy. */
6223
6224       gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
6225       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6226       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6227       gtk_adjustment_changed (tree_view->priv->hadjustment);
6228       gtk_adjustment_changed (tree_view->priv->vadjustment);
6229
6230       if (queue_resize)
6231         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
6232     }
6233
6234   if (path) gtk_tree_path_free (path);
6235
6236   return retval;
6237 }
6238
6239 static gboolean
6240 validate_rows (GtkTreeView *tree_view)
6241 {
6242   gboolean retval;
6243
6244   retval = do_validate_rows (tree_view, TRUE);
6245
6246   if (! retval && tree_view->priv->validate_rows_timer)
6247     {
6248       g_source_remove (tree_view->priv->validate_rows_timer);
6249       tree_view->priv->validate_rows_timer = 0;
6250     }
6251
6252   return retval;
6253 }
6254
6255 static gboolean
6256 validate_rows_handler (GtkTreeView *tree_view)
6257 {
6258   gboolean retval;
6259
6260   retval = do_validate_rows (tree_view, TRUE);
6261   if (! retval && tree_view->priv->validate_rows_timer)
6262     {
6263       g_source_remove (tree_view->priv->validate_rows_timer);
6264       tree_view->priv->validate_rows_timer = 0;
6265     }
6266
6267   return retval;
6268 }
6269
6270 static gboolean
6271 do_presize_handler (GtkTreeView *tree_view)
6272 {
6273   if (tree_view->priv->mark_rows_col_dirty)
6274     {
6275       if (tree_view->priv->tree)
6276         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6277       tree_view->priv->mark_rows_col_dirty = FALSE;
6278     }
6279   validate_visible_area (tree_view);
6280   tree_view->priv->presize_handler_timer = 0;
6281
6282   if (tree_view->priv->fixed_height_mode)
6283     {
6284       GtkRequisition requisition;
6285
6286       gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
6287
6288       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6289       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6290       gtk_adjustment_changed (tree_view->priv->hadjustment);
6291       gtk_adjustment_changed (tree_view->priv->vadjustment);
6292       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6293     }
6294
6295   return FALSE;
6296 }
6297
6298 static gboolean
6299 presize_handler_callback (gpointer data)
6300 {
6301   do_presize_handler (GTK_TREE_VIEW (data));
6302
6303   return FALSE;
6304 }
6305
6306 static void
6307 install_presize_handler (GtkTreeView *tree_view)
6308 {
6309   if (! GTK_WIDGET_REALIZED (tree_view))
6310     return;
6311
6312   if (! tree_view->priv->presize_handler_timer)
6313     {
6314       tree_view->priv->presize_handler_timer =
6315         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6316     }
6317   if (! tree_view->priv->validate_rows_timer)
6318     {
6319       tree_view->priv->validate_rows_timer =
6320         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6321     }
6322 }
6323
6324 static gboolean
6325 scroll_sync_handler (GtkTreeView *tree_view)
6326 {
6327   if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
6328     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6329   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6330     gtk_tree_view_top_row_to_dy (tree_view);
6331   else
6332     gtk_tree_view_dy_to_top_row (tree_view);
6333
6334   tree_view->priv->scroll_sync_timer = 0;
6335
6336   return FALSE;
6337 }
6338
6339 static void
6340 install_scroll_sync_handler (GtkTreeView *tree_view)
6341 {
6342   if (! GTK_WIDGET_REALIZED (tree_view))
6343     return;
6344
6345   if (!tree_view->priv->scroll_sync_timer)
6346     {
6347       tree_view->priv->scroll_sync_timer =
6348         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6349     }
6350 }
6351
6352 static void
6353 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6354                            GtkTreePath *path,
6355                            gint         offset)
6356 {
6357   gtk_tree_row_reference_free (tree_view->priv->top_row);
6358
6359   if (!path)
6360     {
6361       tree_view->priv->top_row = NULL;
6362       tree_view->priv->top_row_dy = 0;
6363     }
6364   else
6365     {
6366       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6367       tree_view->priv->top_row_dy = offset;
6368     }
6369 }
6370
6371 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6372  * it's set to be NULL, and top_row_dy is 0;
6373  */
6374 static void
6375 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6376 {
6377   gint offset;
6378   GtkTreePath *path;
6379   GtkRBTree *tree;
6380   GtkRBNode *node;
6381
6382   if (tree_view->priv->tree == NULL)
6383     {
6384       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6385     }
6386   else
6387     {
6388       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6389                                         tree_view->priv->dy,
6390                                         &tree, &node);
6391
6392       if (tree == NULL)
6393         {
6394           tree_view->priv->top_row = NULL;
6395           tree_view->priv->top_row_dy = 0;
6396         }
6397       else
6398         {
6399           path = _gtk_tree_view_find_path (tree_view, tree, node);
6400           gtk_tree_view_set_top_row (tree_view, path, offset);
6401           gtk_tree_path_free (path);
6402         }
6403     }
6404 }
6405
6406 static void
6407 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6408 {
6409   GtkTreePath *path;
6410   GtkRBTree *tree;
6411   GtkRBNode *node;
6412   int new_dy;
6413
6414   if (tree_view->priv->top_row)
6415     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6416   else
6417     path = NULL;
6418
6419   if (!path)
6420     tree = NULL;
6421   else
6422     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6423
6424   if (path)
6425     gtk_tree_path_free (path);
6426
6427   if (tree == NULL)
6428     {
6429       /* keep dy and set new toprow */
6430       gtk_tree_row_reference_free (tree_view->priv->top_row);
6431       tree_view->priv->top_row = NULL;
6432       tree_view->priv->top_row_dy = 0;
6433       /* DO NOT install the idle handler */
6434       gtk_tree_view_dy_to_top_row (tree_view);
6435       return;
6436     }
6437
6438   if (ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node))
6439       < tree_view->priv->top_row_dy)
6440     {
6441       /* new top row -- do NOT install the idle handler */
6442       gtk_tree_view_dy_to_top_row (tree_view);
6443       return;
6444     }
6445
6446   new_dy = _gtk_rbtree_node_find_offset (tree, node);
6447   new_dy += tree_view->priv->top_row_dy;
6448
6449   if (new_dy + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
6450     new_dy = tree_view->priv->height - tree_view->priv->vadjustment->page_size;
6451
6452   new_dy = MAX (0, new_dy);
6453
6454   tree_view->priv->in_top_row_to_dy = TRUE;
6455   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
6456   tree_view->priv->in_top_row_to_dy = FALSE;
6457 }
6458
6459
6460 void
6461 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view)
6462 {
6463   tree_view->priv->mark_rows_col_dirty = TRUE;
6464
6465   install_presize_handler (tree_view);
6466 }
6467
6468 /*
6469  * This function works synchronously (due to the while (validate_rows...)
6470  * loop).
6471  *
6472  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
6473  * here. You now need to check that yourself.
6474  */
6475 void
6476 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
6477                                 GtkTreeViewColumn *column)
6478 {
6479   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6480   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
6481
6482   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
6483
6484   do_presize_handler (tree_view);
6485   while (validate_rows (tree_view));
6486
6487   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6488 }
6489
6490 /* Drag-and-drop */
6491
6492 static void
6493 set_source_row (GdkDragContext *context,
6494                 GtkTreeModel   *model,
6495                 GtkTreePath    *source_row)
6496 {
6497   g_object_set_data_full (G_OBJECT (context),
6498                           I_("gtk-tree-view-source-row"),
6499                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
6500                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
6501 }
6502
6503 static GtkTreePath*
6504 get_source_row (GdkDragContext *context)
6505 {
6506   GtkTreeRowReference *ref =
6507     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
6508
6509   if (ref)
6510     return gtk_tree_row_reference_get_path (ref);
6511   else
6512     return NULL;
6513 }
6514
6515 typedef struct
6516 {
6517   GtkTreeRowReference *dest_row;
6518   guint                path_down_mode   : 1;
6519   guint                empty_view_drop  : 1;
6520   guint                drop_append_mode : 1;
6521 }
6522 DestRow;
6523
6524 static void
6525 dest_row_free (gpointer data)
6526 {
6527   DestRow *dr = (DestRow *)data;
6528
6529   gtk_tree_row_reference_free (dr->dest_row);
6530   g_slice_free (DestRow, dr);
6531 }
6532
6533 static void
6534 set_dest_row (GdkDragContext *context,
6535               GtkTreeModel   *model,
6536               GtkTreePath    *dest_row,
6537               gboolean        path_down_mode,
6538               gboolean        empty_view_drop,
6539               gboolean        drop_append_mode)
6540 {
6541   DestRow *dr;
6542
6543   if (!dest_row)
6544     {
6545       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
6546                               NULL, NULL);
6547       return;
6548     }
6549
6550   dr = g_slice_new (DestRow);
6551
6552   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
6553   dr->path_down_mode = path_down_mode != FALSE;
6554   dr->empty_view_drop = empty_view_drop != FALSE;
6555   dr->drop_append_mode = drop_append_mode != FALSE;
6556
6557   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
6558                           dr, (GDestroyNotify) dest_row_free);
6559 }
6560
6561 static GtkTreePath*
6562 get_dest_row (GdkDragContext *context,
6563               gboolean       *path_down_mode)
6564 {
6565   DestRow *dr =
6566     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
6567
6568   if (dr)
6569     {
6570       GtkTreePath *path = NULL;
6571
6572       if (path_down_mode)
6573         *path_down_mode = dr->path_down_mode;
6574
6575       if (dr->dest_row)
6576         path = gtk_tree_row_reference_get_path (dr->dest_row);
6577       else if (dr->empty_view_drop)
6578         path = gtk_tree_path_new_from_indices (0, -1);
6579       else
6580         path = NULL;
6581
6582       if (path && dr->drop_append_mode)
6583         gtk_tree_path_next (path);
6584
6585       return path;
6586     }
6587   else
6588     return NULL;
6589 }
6590
6591 /* Get/set whether drag_motion requested the drag data and
6592  * drag_data_received should thus not actually insert the data,
6593  * since the data doesn't result from a drop.
6594  */
6595 static void
6596 set_status_pending (GdkDragContext *context,
6597                     GdkDragAction   suggested_action)
6598 {
6599   g_object_set_data (G_OBJECT (context),
6600                      I_("gtk-tree-view-status-pending"),
6601                      GINT_TO_POINTER (suggested_action));
6602 }
6603
6604 static GdkDragAction
6605 get_status_pending (GdkDragContext *context)
6606 {
6607   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
6608                                              "gtk-tree-view-status-pending"));
6609 }
6610
6611 static TreeViewDragInfo*
6612 get_info (GtkTreeView *tree_view)
6613 {
6614   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
6615 }
6616
6617 static void
6618 destroy_info (TreeViewDragInfo *di)
6619 {
6620   g_slice_free (TreeViewDragInfo, di);
6621 }
6622
6623 static TreeViewDragInfo*
6624 ensure_info (GtkTreeView *tree_view)
6625 {
6626   TreeViewDragInfo *di;
6627
6628   di = get_info (tree_view);
6629
6630   if (di == NULL)
6631     {
6632       di = g_slice_new0 (TreeViewDragInfo);
6633
6634       g_object_set_data_full (G_OBJECT (tree_view),
6635                               I_("gtk-tree-view-drag-info"),
6636                               di,
6637                               (GDestroyNotify) destroy_info);
6638     }
6639
6640   return di;
6641 }
6642
6643 static void
6644 remove_info (GtkTreeView *tree_view)
6645 {
6646   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
6647 }
6648
6649 #if 0
6650 static gint
6651 drag_scan_timeout (gpointer data)
6652 {
6653   GtkTreeView *tree_view;
6654   gint x, y;
6655   GdkModifierType state;
6656   GtkTreePath *path = NULL;
6657   GtkTreeViewColumn *column = NULL;
6658   GdkRectangle visible_rect;
6659
6660   GDK_THREADS_ENTER ();
6661
6662   tree_view = GTK_TREE_VIEW (data);
6663
6664   gdk_window_get_pointer (tree_view->priv->bin_window,
6665                           &x, &y, &state);
6666
6667   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
6668
6669   /* See if we are near the edge. */
6670   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
6671       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
6672       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
6673       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
6674     {
6675       gtk_tree_view_get_path_at_pos (tree_view,
6676                                      tree_view->priv->bin_window,
6677                                      x, y,
6678                                      &path,
6679                                      &column,
6680                                      NULL,
6681                                      NULL);
6682
6683       if (path != NULL)
6684         {
6685           gtk_tree_view_scroll_to_cell (tree_view,
6686                                         path,
6687                                         column,
6688                                         TRUE,
6689                                         0.5, 0.5);
6690
6691           gtk_tree_path_free (path);
6692         }
6693     }
6694
6695   GDK_THREADS_LEAVE ();
6696
6697   return TRUE;
6698 }
6699 #endif /* 0 */
6700
6701 static void
6702 add_scroll_timeout (GtkTreeView *tree_view)
6703 {
6704   if (tree_view->priv->scroll_timeout == 0)
6705     {
6706       tree_view->priv->scroll_timeout =
6707         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
6708     }
6709 }
6710
6711 static void
6712 remove_scroll_timeout (GtkTreeView *tree_view)
6713 {
6714   if (tree_view->priv->scroll_timeout != 0)
6715     {
6716       g_source_remove (tree_view->priv->scroll_timeout);
6717       tree_view->priv->scroll_timeout = 0;
6718     }
6719 }
6720
6721 static gboolean
6722 check_model_dnd (GtkTreeModel *model,
6723                  GType         required_iface,
6724                  const gchar  *signal)
6725 {
6726   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
6727     {
6728       g_warning ("You must override the default '%s' handler "
6729                  "on GtkTreeView when using models that don't support "
6730                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
6731                  "is to connect to '%s' and call "
6732                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
6733                  "the default handler from running. Look at the source code "
6734                  "for the default handler in gtktreeview.c to get an idea what "
6735                  "your handler should do. (gtktreeview.c is in the GTK source "
6736                  "code.) If you're using GTK from a language other than C, "
6737                  "there may be a more natural way to override default handlers, e.g. via derivation.",
6738                  signal, g_type_name (required_iface), signal);
6739       return FALSE;
6740     }
6741   else
6742     return TRUE;
6743 }
6744
6745 static void
6746 remove_open_timeout (GtkTreeView *tree_view)
6747 {
6748   if (tree_view->priv->open_dest_timeout != 0)
6749     {
6750       g_source_remove (tree_view->priv->open_dest_timeout);
6751       tree_view->priv->open_dest_timeout = 0;
6752     }
6753 }
6754
6755
6756 static gint
6757 open_row_timeout (gpointer data)
6758 {
6759   GtkTreeView *tree_view = data;
6760   GtkTreePath *dest_path = NULL;
6761   GtkTreeViewDropPosition pos;
6762   gboolean result = FALSE;
6763
6764   gtk_tree_view_get_drag_dest_row (tree_view,
6765                                    &dest_path,
6766                                    &pos);
6767
6768   if (dest_path &&
6769       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
6770        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
6771     {
6772       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
6773       tree_view->priv->open_dest_timeout = 0;
6774
6775       gtk_tree_path_free (dest_path);
6776     }
6777   else
6778     {
6779       if (dest_path)
6780         gtk_tree_path_free (dest_path);
6781
6782       result = TRUE;
6783     }
6784
6785   return result;
6786 }
6787
6788 static gboolean
6789 scroll_row_timeout (gpointer data)
6790 {
6791   GtkTreeView *tree_view = data;
6792
6793   gtk_tree_view_vertical_autoscroll (tree_view);
6794
6795   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
6796     gtk_tree_view_update_rubber_band (tree_view);
6797
6798   return TRUE;
6799 }
6800
6801 /* Returns TRUE if event should not be propagated to parent widgets */
6802 static gboolean
6803 set_destination_row (GtkTreeView    *tree_view,
6804                      GdkDragContext *context,
6805                      /* coordinates relative to the widget */
6806                      gint            x,
6807                      gint            y,
6808                      GdkDragAction  *suggested_action,
6809                      GdkAtom        *target)
6810 {
6811   GtkTreePath *path = NULL;
6812   GtkTreeViewDropPosition pos;
6813   GtkTreeViewDropPosition old_pos;
6814   TreeViewDragInfo *di;
6815   GtkWidget *widget;
6816   GtkTreePath *old_dest_path = NULL;
6817   gboolean can_drop = FALSE;
6818
6819   *suggested_action = 0;
6820   *target = GDK_NONE;
6821
6822   widget = GTK_WIDGET (tree_view);
6823
6824   di = get_info (tree_view);
6825
6826   if (di == NULL || y - TREE_VIEW_HEADER_HEIGHT (tree_view) < 0)
6827     {
6828       /* someone unset us as a drag dest, note that if
6829        * we return FALSE drag_leave isn't called
6830        */
6831
6832       gtk_tree_view_set_drag_dest_row (tree_view,
6833                                        NULL,
6834                                        GTK_TREE_VIEW_DROP_BEFORE);
6835
6836       remove_scroll_timeout (GTK_TREE_VIEW (widget));
6837       remove_open_timeout (GTK_TREE_VIEW (widget));
6838
6839       return FALSE; /* no longer a drop site */
6840     }
6841
6842   *target = gtk_drag_dest_find_target (widget, context,
6843                                        gtk_drag_dest_get_target_list (widget));
6844   if (*target == GDK_NONE)
6845     {
6846       return FALSE;
6847     }
6848
6849   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
6850                                           x, y,
6851                                           &path,
6852                                           &pos))
6853     {
6854       gint n_children;
6855       GtkTreeModel *model;
6856
6857       remove_open_timeout (tree_view);
6858
6859       /* the row got dropped on empty space, let's setup a special case
6860        */
6861
6862       if (path)
6863         gtk_tree_path_free (path);
6864
6865       model = gtk_tree_view_get_model (tree_view);
6866
6867       n_children = gtk_tree_model_iter_n_children (model, NULL);
6868       if (n_children)
6869         {
6870           pos = GTK_TREE_VIEW_DROP_AFTER;
6871           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
6872         }
6873       else
6874         {
6875           pos = GTK_TREE_VIEW_DROP_BEFORE;
6876           path = gtk_tree_path_new_from_indices (0, -1);
6877         }
6878
6879       can_drop = TRUE;
6880
6881       goto out;
6882     }
6883
6884   g_assert (path);
6885
6886   /* If we left the current row's "open" zone, unset the timeout for
6887    * opening the row
6888    */
6889   gtk_tree_view_get_drag_dest_row (tree_view,
6890                                    &old_dest_path,
6891                                    &old_pos);
6892
6893   if (old_dest_path &&
6894       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
6895        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
6896          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
6897     remove_open_timeout (tree_view);
6898
6899   if (old_dest_path)
6900     gtk_tree_path_free (old_dest_path);
6901
6902   if (TRUE /* FIXME if the location droppable predicate */)
6903     {
6904       can_drop = TRUE;
6905     }
6906
6907 out:
6908   if (can_drop)
6909     {
6910       GtkWidget *source_widget;
6911
6912       *suggested_action = context->suggested_action;
6913       source_widget = gtk_drag_get_source_widget (context);
6914
6915       if (source_widget == widget)
6916         {
6917           /* Default to MOVE, unless the user has
6918            * pressed ctrl or shift to affect available actions
6919            */
6920           if ((context->actions & GDK_ACTION_MOVE) != 0)
6921             *suggested_action = GDK_ACTION_MOVE;
6922         }
6923
6924       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
6925                                        path, pos);
6926     }
6927   else
6928     {
6929       /* can't drop here */
6930       remove_open_timeout (tree_view);
6931
6932       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
6933                                        NULL,
6934                                        GTK_TREE_VIEW_DROP_BEFORE);
6935     }
6936
6937   if (path)
6938     gtk_tree_path_free (path);
6939
6940   return TRUE;
6941 }
6942
6943 static GtkTreePath*
6944 get_logical_dest_row (GtkTreeView *tree_view,
6945                       gboolean    *path_down_mode,
6946                       gboolean    *drop_append_mode)
6947 {
6948   /* adjust path to point to the row the drop goes in front of */
6949   GtkTreePath *path = NULL;
6950   GtkTreeViewDropPosition pos;
6951
6952   g_return_val_if_fail (path_down_mode != NULL, NULL);
6953   g_return_val_if_fail (drop_append_mode != NULL, NULL);
6954
6955   *path_down_mode = FALSE;
6956   *drop_append_mode = 0;
6957
6958   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
6959
6960   if (path == NULL)
6961     return NULL;
6962
6963   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
6964     ; /* do nothing */
6965   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
6966            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
6967     *path_down_mode = TRUE;
6968   else
6969     {
6970       GtkTreeIter iter;
6971       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
6972
6973       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
6974
6975       if (!gtk_tree_model_get_iter (model, &iter, path) ||
6976           !gtk_tree_model_iter_next (model, &iter))
6977         *drop_append_mode = 1;
6978       else
6979         {
6980           *drop_append_mode = 0;
6981           gtk_tree_path_next (path);
6982         }
6983     }
6984
6985   return path;
6986 }
6987
6988 static gboolean
6989 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
6990                                         GdkEventMotion   *event)
6991 {
6992   GtkWidget *widget = GTK_WIDGET (tree_view);
6993   GdkDragContext *context;
6994   TreeViewDragInfo *di;
6995   GtkTreePath *path = NULL;
6996   gint button;
6997   gint cell_x, cell_y;
6998   GtkTreeModel *model;
6999   gboolean retval = FALSE;
7000
7001   di = get_info (tree_view);
7002
7003   if (di == NULL || !di->source_set)
7004     goto out;
7005
7006   if (tree_view->priv->pressed_button < 0)
7007     goto out;
7008
7009   if (!gtk_drag_check_threshold (widget,
7010                                  tree_view->priv->press_start_x,
7011                                  tree_view->priv->press_start_y,
7012                                  event->x, event->y))
7013     goto out;
7014
7015   model = gtk_tree_view_get_model (tree_view);
7016
7017   if (model == NULL)
7018     goto out;
7019
7020   button = tree_view->priv->pressed_button;
7021   tree_view->priv->pressed_button = -1;
7022
7023   gtk_tree_view_get_path_at_pos (tree_view,
7024                                  tree_view->priv->press_start_x,
7025                                  tree_view->priv->press_start_y,
7026                                  &path,
7027                                  NULL,
7028                                  &cell_x,
7029                                  &cell_y);
7030
7031   if (path == NULL)
7032     goto out;
7033
7034   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7035       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7036                                            path))
7037     goto out;
7038
7039   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7040     goto out;
7041
7042   /* Now we can begin the drag */
7043
7044   retval = TRUE;
7045
7046   context = gtk_drag_begin (widget,
7047                             gtk_drag_source_get_target_list (widget),
7048                             di->source_actions,
7049                             button,
7050                             (GdkEvent*)event);
7051
7052   set_source_row (context, model, path);
7053
7054  out:
7055   if (path)
7056     gtk_tree_path_free (path);
7057
7058   return retval;
7059 }
7060
7061
7062 static void
7063 gtk_tree_view_drag_begin (GtkWidget      *widget,
7064                           GdkDragContext *context)
7065 {
7066   GtkTreeView *tree_view;
7067   GtkTreePath *path = NULL;
7068   gint cell_x, cell_y;
7069   GdkPixmap *row_pix;
7070   TreeViewDragInfo *di;
7071
7072   tree_view = GTK_TREE_VIEW (widget);
7073
7074   /* if the user uses a custom DND source impl, we don't set the icon here */
7075   di = get_info (tree_view);
7076
7077   if (di == NULL || !di->source_set)
7078     return;
7079
7080   gtk_tree_view_get_path_at_pos (tree_view,
7081                                  tree_view->priv->press_start_x,
7082                                  tree_view->priv->press_start_y,
7083                                  &path,
7084                                  NULL,
7085                                  &cell_x,
7086                                  &cell_y);
7087
7088   g_return_if_fail (path != NULL);
7089
7090   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7091                                                 path);
7092
7093   gtk_drag_set_icon_pixmap (context,
7094                             gdk_drawable_get_colormap (row_pix),
7095                             row_pix,
7096                             NULL,
7097                             /* the + 1 is for the black border in the icon */
7098                             tree_view->priv->press_start_x + 1,
7099                             cell_y + 1);
7100
7101   g_object_unref (row_pix);
7102   gtk_tree_path_free (path);
7103 }
7104
7105 static void
7106 gtk_tree_view_drag_end (GtkWidget      *widget,
7107                         GdkDragContext *context)
7108 {
7109   /* do nothing */
7110 }
7111
7112 /* Default signal implementations for the drag signals */
7113 static void
7114 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7115                              GdkDragContext   *context,
7116                              GtkSelectionData *selection_data,
7117                              guint             info,
7118                              guint             time)
7119 {
7120   GtkTreeView *tree_view;
7121   GtkTreeModel *model;
7122   TreeViewDragInfo *di;
7123   GtkTreePath *source_row;
7124
7125   tree_view = GTK_TREE_VIEW (widget);
7126
7127   model = gtk_tree_view_get_model (tree_view);
7128
7129   if (model == NULL)
7130     return;
7131
7132   di = get_info (GTK_TREE_VIEW (widget));
7133
7134   if (di == NULL)
7135     return;
7136
7137   source_row = get_source_row (context);
7138
7139   if (source_row == NULL)
7140     return;
7141
7142   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7143    * any model; for DragSource models there are some other targets
7144    * we also support.
7145    */
7146
7147   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7148       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7149                                           source_row,
7150                                           selection_data))
7151     goto done;
7152
7153   /* If drag_data_get does nothing, try providing row data. */
7154   if (selection_data->target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7155     {
7156       gtk_tree_set_row_drag_data (selection_data,
7157                                   model,
7158                                   source_row);
7159     }
7160
7161  done:
7162   gtk_tree_path_free (source_row);
7163 }
7164
7165
7166 static void
7167 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7168                                 GdkDragContext *context)
7169 {
7170   TreeViewDragInfo *di;
7171   GtkTreeModel *model;
7172   GtkTreeView *tree_view;
7173   GtkTreePath *source_row;
7174
7175   tree_view = GTK_TREE_VIEW (widget);
7176   model = gtk_tree_view_get_model (tree_view);
7177
7178   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7179     return;
7180
7181   di = get_info (tree_view);
7182
7183   if (di == NULL)
7184     return;
7185
7186   source_row = get_source_row (context);
7187
7188   if (source_row == NULL)
7189     return;
7190
7191   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7192                                          source_row);
7193
7194   gtk_tree_path_free (source_row);
7195
7196   set_source_row (context, NULL, NULL);
7197 }
7198
7199 static void
7200 gtk_tree_view_drag_leave (GtkWidget      *widget,
7201                           GdkDragContext *context,
7202                           guint             time)
7203 {
7204   /* unset any highlight row */
7205   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7206                                    NULL,
7207                                    GTK_TREE_VIEW_DROP_BEFORE);
7208
7209   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7210   remove_open_timeout (GTK_TREE_VIEW (widget));
7211 }
7212
7213
7214 static gboolean
7215 gtk_tree_view_drag_motion (GtkWidget        *widget,
7216                            GdkDragContext   *context,
7217                            /* coordinates relative to the widget */
7218                            gint              x,
7219                            gint              y,
7220                            guint             time)
7221 {
7222   gboolean empty;
7223   GtkTreePath *path = NULL;
7224   GtkTreeViewDropPosition pos;
7225   GtkTreeView *tree_view;
7226   GdkDragAction suggested_action = 0;
7227   GdkAtom target;
7228
7229   tree_view = GTK_TREE_VIEW (widget);
7230
7231   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7232     return FALSE;
7233
7234   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7235
7236   /* we only know this *after* set_desination_row */
7237   empty = tree_view->priv->empty_view_drop;
7238
7239   if (path == NULL && !empty)
7240     {
7241       /* Can't drop here. */
7242       gdk_drag_status (context, 0, time);
7243     }
7244   else
7245     {
7246       if (tree_view->priv->open_dest_timeout == 0 &&
7247           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7248            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7249         {
7250           tree_view->priv->open_dest_timeout =
7251             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7252         }
7253       else
7254         {
7255           add_scroll_timeout (tree_view);
7256         }
7257
7258       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7259         {
7260           /* Request data so we can use the source row when
7261            * determining whether to accept the drop
7262            */
7263           set_status_pending (context, suggested_action);
7264           gtk_drag_get_data (widget, context, target, time);
7265         }
7266       else
7267         {
7268           set_status_pending (context, 0);
7269           gdk_drag_status (context, suggested_action, time);
7270         }
7271     }
7272
7273   if (path)
7274     gtk_tree_path_free (path);
7275
7276   return TRUE;
7277 }
7278
7279
7280 static gboolean
7281 gtk_tree_view_drag_drop (GtkWidget        *widget,
7282                          GdkDragContext   *context,
7283                          /* coordinates relative to the widget */
7284                          gint              x,
7285                          gint              y,
7286                          guint             time)
7287 {
7288   GtkTreeView *tree_view;
7289   GtkTreePath *path;
7290   GdkDragAction suggested_action = 0;
7291   GdkAtom target = GDK_NONE;
7292   TreeViewDragInfo *di;
7293   GtkTreeModel *model;
7294   gboolean path_down_mode;
7295   gboolean drop_append_mode;
7296
7297   tree_view = GTK_TREE_VIEW (widget);
7298
7299   model = gtk_tree_view_get_model (tree_view);
7300
7301   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7302   remove_open_timeout (GTK_TREE_VIEW (widget));
7303
7304   di = get_info (tree_view);
7305
7306   if (di == NULL)
7307     return FALSE;
7308
7309   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7310     return FALSE;
7311
7312   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7313     return FALSE;
7314
7315   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7316
7317   if (target != GDK_NONE && path != NULL)
7318     {
7319       /* in case a motion had requested drag data, change things so we
7320        * treat drag data receives as a drop.
7321        */
7322       set_status_pending (context, 0);
7323       set_dest_row (context, model, path,
7324                     path_down_mode, tree_view->priv->empty_view_drop,
7325                     drop_append_mode);
7326     }
7327
7328   if (path)
7329     gtk_tree_path_free (path);
7330
7331   /* Unset this thing */
7332   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7333                                    NULL,
7334                                    GTK_TREE_VIEW_DROP_BEFORE);
7335
7336   if (target != GDK_NONE)
7337     {
7338       gtk_drag_get_data (widget, context, target, time);
7339       return TRUE;
7340     }
7341   else
7342     return FALSE;
7343 }
7344
7345 static void
7346 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7347                                   GdkDragContext   *context,
7348                                   /* coordinates relative to the widget */
7349                                   gint              x,
7350                                   gint              y,
7351                                   GtkSelectionData *selection_data,
7352                                   guint             info,
7353                                   guint             time)
7354 {
7355   GtkTreePath *path;
7356   TreeViewDragInfo *di;
7357   gboolean accepted = FALSE;
7358   GtkTreeModel *model;
7359   GtkTreeView *tree_view;
7360   GtkTreePath *dest_row;
7361   GdkDragAction suggested_action;
7362   gboolean path_down_mode;
7363   gboolean drop_append_mode;
7364
7365   tree_view = GTK_TREE_VIEW (widget);
7366
7367   model = gtk_tree_view_get_model (tree_view);
7368
7369   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7370     return;
7371
7372   di = get_info (tree_view);
7373
7374   if (di == NULL)
7375     return;
7376
7377   suggested_action = get_status_pending (context);
7378
7379   if (suggested_action)
7380     {
7381       /* We are getting this data due to a request in drag_motion,
7382        * rather than due to a request in drag_drop, so we are just
7383        * supposed to call drag_status, not actually paste in the
7384        * data.
7385        */
7386       path = get_logical_dest_row (tree_view, &path_down_mode,
7387                                    &drop_append_mode);
7388
7389       if (path == NULL)
7390         suggested_action = 0;
7391       else if (path_down_mode)
7392         gtk_tree_path_down (path);
7393
7394       if (suggested_action)
7395         {
7396           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7397                                                      path,
7398                                                      selection_data))
7399             {
7400               if (path_down_mode)
7401                 {
7402                   path_down_mode = FALSE;
7403                   gtk_tree_path_up (path);
7404
7405                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7406                                                              path,
7407                                                              selection_data))
7408                     suggested_action = 0;
7409                 }
7410               else
7411                 suggested_action = 0;
7412             }
7413         }
7414
7415       gdk_drag_status (context, suggested_action, time);
7416
7417       if (path)
7418         gtk_tree_path_free (path);
7419
7420       /* If you can't drop, remove user drop indicator until the next motion */
7421       if (suggested_action == 0)
7422         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7423                                          NULL,
7424                                          GTK_TREE_VIEW_DROP_BEFORE);
7425
7426       return;
7427     }
7428
7429   dest_row = get_dest_row (context, &path_down_mode);
7430
7431   if (dest_row == NULL)
7432     return;
7433
7434   if (selection_data->length >= 0)
7435     {
7436       if (path_down_mode)
7437         {
7438           gtk_tree_path_down (dest_row);
7439           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7440                                                      dest_row, selection_data))
7441             gtk_tree_path_up (dest_row);
7442         }
7443     }
7444
7445   if (selection_data->length >= 0)
7446     {
7447       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
7448                                                  dest_row,
7449                                                  selection_data))
7450         accepted = TRUE;
7451     }
7452
7453   gtk_drag_finish (context,
7454                    accepted,
7455                    (context->action == GDK_ACTION_MOVE),
7456                    time);
7457
7458   if (gtk_tree_path_get_depth (dest_row) == 1
7459       && gtk_tree_path_get_indices (dest_row)[0] == 0)
7460     {
7461       /* special special case drag to "0", scroll to first item */
7462       if (!tree_view->priv->scroll_to_path)
7463         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
7464     }
7465
7466   gtk_tree_path_free (dest_row);
7467
7468   /* drop dest_row */
7469   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
7470 }
7471
7472
7473
7474 /* GtkContainer Methods
7475  */
7476
7477
7478 static void
7479 gtk_tree_view_remove (GtkContainer *container,
7480                       GtkWidget    *widget)
7481 {
7482   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7483   GtkTreeViewChild *child = NULL;
7484   GList *tmp_list;
7485
7486   tmp_list = tree_view->priv->children;
7487   while (tmp_list)
7488     {
7489       child = tmp_list->data;
7490       if (child->widget == widget)
7491         {
7492           gtk_widget_unparent (widget);
7493
7494           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
7495           g_list_free_1 (tmp_list);
7496           g_slice_free (GtkTreeViewChild, child);
7497           return;
7498         }
7499
7500       tmp_list = tmp_list->next;
7501     }
7502
7503   tmp_list = tree_view->priv->columns;
7504
7505   while (tmp_list)
7506     {
7507       GtkTreeViewColumn *column;
7508       column = tmp_list->data;
7509       if (column->button == widget)
7510         {
7511           gtk_widget_unparent (widget);
7512           return;
7513         }
7514       tmp_list = tmp_list->next;
7515     }
7516 }
7517
7518 static void
7519 gtk_tree_view_forall (GtkContainer *container,
7520                       gboolean      include_internals,
7521                       GtkCallback   callback,
7522                       gpointer      callback_data)
7523 {
7524   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7525   GtkTreeViewChild *child = NULL;
7526   GtkTreeViewColumn *column;
7527   GList *tmp_list;
7528
7529   tmp_list = tree_view->priv->children;
7530   while (tmp_list)
7531     {
7532       child = tmp_list->data;
7533       tmp_list = tmp_list->next;
7534
7535       (* callback) (child->widget, callback_data);
7536     }
7537   if (include_internals == FALSE)
7538     return;
7539
7540   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
7541     {
7542       column = tmp_list->data;
7543
7544       if (column->button)
7545         (* callback) (column->button, callback_data);
7546     }
7547 }
7548
7549 /* Returns TRUE if the treeview contains no "special" (editable or activatable)
7550  * cells. If so we draw one big row-spanning focus rectangle.
7551  */
7552 static gboolean
7553 gtk_tree_view_has_special_cell (GtkTreeView *tree_view)
7554 {
7555   GList *list;
7556
7557   for (list = tree_view->priv->columns; list; list = list->next)
7558     {
7559       if (!((GtkTreeViewColumn *)list->data)->visible)
7560         continue;
7561       if (_gtk_tree_view_column_count_special_cells (list->data))
7562         return TRUE;
7563     }
7564
7565   return FALSE;
7566 }
7567
7568 static void
7569 column_sizing_notify (GObject    *object,
7570                       GParamSpec *pspec,
7571                       gpointer    data)
7572 {
7573   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
7574
7575   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
7576     /* disable fixed height mode */
7577     g_object_set (data, "fixed-height-mode", FALSE, NULL);
7578 }
7579
7580 /**
7581  * gtk_tree_view_set_fixed_height_mode:
7582  * @tree_view: a #GtkTreeView
7583  * @enable: %TRUE to enable fixed height mode
7584  *
7585  * Enables or disables the fixed height mode of @tree_view.
7586  * Fixed height mode speeds up #GtkTreeView by assuming that all
7587  * rows have the same height.
7588  * Only enable this option if all rows are the same height and all
7589  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
7590  *
7591  * Since: 2.6
7592  **/
7593 void
7594 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
7595                                      gboolean     enable)
7596 {
7597   GList *l;
7598
7599   enable = enable != FALSE;
7600
7601   if (enable == tree_view->priv->fixed_height_mode)
7602     return;
7603
7604   if (!enable)
7605     {
7606       tree_view->priv->fixed_height_mode = 0;
7607       tree_view->priv->fixed_height = -1;
7608
7609       /* force a revalidation */
7610       install_presize_handler (tree_view);
7611     }
7612   else
7613     {
7614       /* make sure all columns are of type FIXED */
7615       for (l = tree_view->priv->columns; l; l = l->next)
7616         {
7617           GtkTreeViewColumn *c = l->data;
7618
7619           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
7620         }
7621
7622       /* yes, we really have to do this is in a separate loop */
7623       for (l = tree_view->priv->columns; l; l = l->next)
7624         g_signal_connect (l->data, "notify::sizing",
7625                           G_CALLBACK (column_sizing_notify), tree_view);
7626
7627       tree_view->priv->fixed_height_mode = 1;
7628       tree_view->priv->fixed_height = -1;
7629
7630       if (tree_view->priv->tree)
7631         initialize_fixed_height_mode (tree_view);
7632     }
7633
7634   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
7635 }
7636
7637 /**
7638  * gtk_tree_view_get_fixed_height_mode:
7639  * @tree_view: a #GtkTreeView
7640  *
7641  * Returns whether fixed height mode is turned on for @tree_view.
7642  *
7643  * Return value: %TRUE if @tree_view is in fixed height mode
7644  *
7645  * Since: 2.6
7646  **/
7647 gboolean
7648 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
7649 {
7650   return tree_view->priv->fixed_height_mode;
7651 }
7652
7653 /* Returns TRUE if the focus is within the headers, after the focus operation is
7654  * done
7655  */
7656 static gboolean
7657 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
7658                             GtkDirectionType  dir,
7659                             gboolean          clamp_column_visible)
7660 {
7661   GtkWidget *focus_child;
7662
7663   GList *last_column, *first_column;
7664   GList *tmp_list;
7665   gboolean rtl;
7666
7667   if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
7668     return FALSE;
7669
7670   focus_child = GTK_CONTAINER (tree_view)->focus_child;
7671
7672   first_column = tree_view->priv->columns;
7673   while (first_column)
7674     {
7675       if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (first_column->data)->button) &&
7676           GTK_TREE_VIEW_COLUMN (first_column->data)->visible &&
7677           (GTK_TREE_VIEW_COLUMN (first_column->data)->clickable ||
7678            GTK_TREE_VIEW_COLUMN (first_column->data)->reorderable))
7679         break;
7680       first_column = first_column->next;
7681     }
7682
7683   /* No headers are visible, or are focusable.  We can't focus in or out.
7684    */
7685   if (first_column == NULL)
7686     return FALSE;
7687
7688   last_column = g_list_last (tree_view->priv->columns);
7689   while (last_column)
7690     {
7691       if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (last_column->data)->button) &&
7692           GTK_TREE_VIEW_COLUMN (last_column->data)->visible &&
7693           (GTK_TREE_VIEW_COLUMN (last_column->data)->clickable ||
7694            GTK_TREE_VIEW_COLUMN (last_column->data)->reorderable))
7695         break;
7696       last_column = last_column->prev;
7697     }
7698
7699
7700   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
7701
7702   switch (dir)
7703     {
7704     case GTK_DIR_TAB_BACKWARD:
7705     case GTK_DIR_TAB_FORWARD:
7706     case GTK_DIR_UP:
7707     case GTK_DIR_DOWN:
7708       if (focus_child == NULL)
7709         {
7710           if (tree_view->priv->focus_column != NULL)
7711             focus_child = tree_view->priv->focus_column->button;
7712           else
7713             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
7714           gtk_widget_grab_focus (focus_child);
7715           break;
7716         }
7717       return FALSE;
7718
7719     case GTK_DIR_LEFT:
7720     case GTK_DIR_RIGHT:
7721       if (focus_child == NULL)
7722         {
7723           if (tree_view->priv->focus_column != NULL)
7724             focus_child = tree_view->priv->focus_column->button;
7725           else if (dir == GTK_DIR_LEFT)
7726             focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
7727           else
7728             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
7729           gtk_widget_grab_focus (focus_child);
7730           break;
7731         }
7732
7733       if (gtk_widget_child_focus (focus_child, dir))
7734         {
7735           /* The focus moves inside the button. */
7736           /* This is probably a great example of bad UI */
7737           break;
7738         }
7739
7740       /* We need to move the focus among the row of buttons. */
7741       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
7742         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
7743           break;
7744
7745       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
7746           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
7747         {
7748           gtk_widget_error_bell (GTK_WIDGET (tree_view));
7749           break;
7750         }
7751
7752       while (tmp_list)
7753         {
7754           GtkTreeViewColumn *column;
7755
7756           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
7757             tmp_list = tmp_list->next;
7758           else
7759             tmp_list = tmp_list->prev;
7760
7761           if (tmp_list == NULL)
7762             {
7763               g_warning ("Internal button not found");
7764               break;
7765             }
7766           column = tmp_list->data;
7767           if (column->button &&
7768               column->visible &&
7769               GTK_WIDGET_CAN_FOCUS (column->button))
7770             {
7771               focus_child = column->button;
7772               gtk_widget_grab_focus (column->button);
7773               break;
7774             }
7775         }
7776       break;
7777     default:
7778       g_assert_not_reached ();
7779       break;
7780     }
7781
7782   /* if focus child is non-null, we assume it's been set to the current focus child
7783    */
7784   if (focus_child)
7785     {
7786       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
7787         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
7788           {
7789             tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
7790             break;
7791           }
7792
7793       if (clamp_column_visible)
7794         {
7795           gtk_tree_view_clamp_column_visible (tree_view,
7796                                               tree_view->priv->focus_column,
7797                                               FALSE);
7798         }
7799     }
7800
7801   return (focus_child != NULL);
7802 }
7803
7804 /* This function returns in 'path' the first focusable path, if the given path
7805  * is already focusable, it's the returned one.
7806  */
7807 static gboolean
7808 search_first_focusable_path (GtkTreeView  *tree_view,
7809                              GtkTreePath **path,
7810                              gboolean      search_forward,
7811                              GtkRBTree   **new_tree,
7812                              GtkRBNode   **new_node)
7813 {
7814   GtkRBTree *tree = NULL;
7815   GtkRBNode *node = NULL;
7816
7817   if (!path || !*path)
7818     return FALSE;
7819
7820   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
7821
7822   if (!tree || !node)
7823     return FALSE;
7824
7825   while (node && row_is_separator (tree_view, NULL, *path))
7826     {
7827       if (search_forward)
7828         _gtk_rbtree_next_full (tree, node, &tree, &node);
7829       else
7830         _gtk_rbtree_prev_full (tree, node, &tree, &node);
7831
7832       if (*path)
7833         gtk_tree_path_free (*path);
7834
7835       if (node)
7836         *path = _gtk_tree_view_find_path (tree_view, tree, node);
7837       else
7838         *path = NULL;
7839     }
7840
7841   if (new_tree)
7842     *new_tree = tree;
7843
7844   if (new_node)
7845     *new_node = node;
7846
7847   return (*path != NULL);
7848 }
7849
7850 static gint
7851 gtk_tree_view_focus (GtkWidget        *widget,
7852                      GtkDirectionType  direction)
7853 {
7854   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
7855   GtkContainer *container = GTK_CONTAINER (widget);
7856   GtkWidget *focus_child;
7857
7858   if (!GTK_WIDGET_IS_SENSITIVE (container) || !GTK_WIDGET_CAN_FOCUS (widget))
7859     return FALSE;
7860
7861   focus_child = container->focus_child;
7862
7863   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
7864   /* Case 1.  Headers currently have focus. */
7865   if (focus_child)
7866     {
7867       switch (direction)
7868         {
7869         case GTK_DIR_LEFT:
7870         case GTK_DIR_RIGHT:
7871           gtk_tree_view_header_focus (tree_view, direction, TRUE);
7872           return TRUE;
7873         case GTK_DIR_TAB_BACKWARD:
7874         case GTK_DIR_UP:
7875           return FALSE;
7876         case GTK_DIR_TAB_FORWARD:
7877         case GTK_DIR_DOWN:
7878           gtk_widget_grab_focus (widget);
7879           return TRUE;
7880         default:
7881           g_assert_not_reached ();
7882           return FALSE;
7883         }
7884     }
7885
7886   /* Case 2. We don't have focus at all. */
7887   if (!GTK_WIDGET_HAS_FOCUS (container))
7888     {
7889       if (!gtk_tree_view_header_focus (tree_view, direction, FALSE))
7890         gtk_widget_grab_focus (widget);
7891       return TRUE;
7892     }
7893
7894   /* Case 3. We have focus already. */
7895   if (direction == GTK_DIR_TAB_BACKWARD)
7896     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
7897   else if (direction == GTK_DIR_TAB_FORWARD)
7898     return FALSE;
7899
7900   /* Other directions caught by the keybindings */
7901   gtk_widget_grab_focus (widget);
7902   return TRUE;
7903 }
7904
7905 static void
7906 gtk_tree_view_grab_focus (GtkWidget *widget)
7907 {
7908   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
7909
7910   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
7911 }
7912
7913 static void
7914 gtk_tree_view_style_set (GtkWidget *widget,
7915                          GtkStyle *previous_style)
7916 {
7917   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
7918   GList *list;
7919   GtkTreeViewColumn *column;
7920
7921   if (GTK_WIDGET_REALIZED (widget))
7922     {
7923       gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
7924       gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
7925       gtk_style_set_background (widget->style, tree_view->priv->header_window, GTK_STATE_NORMAL);
7926
7927       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
7928       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
7929     }
7930
7931   gtk_widget_style_get (widget,
7932                         "expander-size", &tree_view->priv->expander_size,
7933                         NULL);
7934   tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
7935
7936   for (list = tree_view->priv->columns; list; list = list->next)
7937     {
7938       column = list->data;
7939       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
7940     }
7941
7942   tree_view->priv->fixed_height = -1;
7943   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
7944
7945   gtk_widget_queue_resize (widget);
7946 }
7947
7948
7949 static void
7950 gtk_tree_view_set_focus_child (GtkContainer *container,
7951                                GtkWidget    *child)
7952 {
7953   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7954   GList *list;
7955
7956   for (list = tree_view->priv->columns; list; list = list->next)
7957     {
7958       if (GTK_TREE_VIEW_COLUMN (list->data)->button == child)
7959         {
7960           tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
7961           break;
7962         }
7963     }
7964
7965   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
7966 }
7967
7968 static void
7969 gtk_tree_view_set_adjustments (GtkTreeView   *tree_view,
7970                                GtkAdjustment *hadj,
7971                                GtkAdjustment *vadj)
7972 {
7973   gboolean need_adjust = FALSE;
7974
7975   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7976
7977   if (hadj)
7978     g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
7979   else
7980     hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
7981   if (vadj)
7982     g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
7983   else
7984     vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
7985
7986   if (tree_view->priv->hadjustment && (tree_view->priv->hadjustment != hadj))
7987     {
7988       g_signal_handlers_disconnect_by_func (tree_view->priv->hadjustment,
7989                                             gtk_tree_view_adjustment_changed,
7990                                             tree_view);
7991       g_object_unref (tree_view->priv->hadjustment);
7992     }
7993
7994   if (tree_view->priv->vadjustment && (tree_view->priv->vadjustment != vadj))
7995     {
7996       g_signal_handlers_disconnect_by_func (tree_view->priv->vadjustment,
7997                                             gtk_tree_view_adjustment_changed,
7998                                             tree_view);
7999       g_object_unref (tree_view->priv->vadjustment);
8000     }
8001
8002   if (tree_view->priv->hadjustment != hadj)
8003     {
8004       tree_view->priv->hadjustment = hadj;
8005       g_object_ref_sink (tree_view->priv->hadjustment);
8006
8007       g_signal_connect (tree_view->priv->hadjustment, "value-changed",
8008                         G_CALLBACK (gtk_tree_view_adjustment_changed),
8009                         tree_view);
8010       need_adjust = TRUE;
8011     }
8012
8013   if (tree_view->priv->vadjustment != vadj)
8014     {
8015       tree_view->priv->vadjustment = vadj;
8016       g_object_ref_sink (tree_view->priv->vadjustment);
8017
8018       g_signal_connect (tree_view->priv->vadjustment, "value-changed",
8019                         G_CALLBACK (gtk_tree_view_adjustment_changed),
8020                         tree_view);
8021       need_adjust = TRUE;
8022     }
8023
8024   if (need_adjust)
8025     gtk_tree_view_adjustment_changed (NULL, tree_view);
8026 }
8027
8028
8029 static gboolean
8030 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8031                                 GtkMovementStep    step,
8032                                 gint               count)
8033 {
8034   GdkModifierType state;
8035
8036   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8037   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8038                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8039                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8040                         step == GTK_MOVEMENT_PAGES ||
8041                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8042
8043   if (tree_view->priv->tree == NULL)
8044     return FALSE;
8045   if (!GTK_WIDGET_HAS_FOCUS (GTK_WIDGET (tree_view)))
8046     return FALSE;
8047
8048   gtk_tree_view_stop_editing (tree_view, FALSE);
8049   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
8050   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8051
8052   if (gtk_get_current_event_state (&state))
8053     {
8054       if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
8055         tree_view->priv->ctrl_pressed = TRUE;
8056       if ((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
8057         tree_view->priv->shift_pressed = TRUE;
8058     }
8059   /* else we assume not pressed */
8060
8061   switch (step)
8062     {
8063       /* currently we make no distinction.  When we go bi-di, we need to */
8064     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8065     case GTK_MOVEMENT_VISUAL_POSITIONS:
8066       gtk_tree_view_move_cursor_left_right (tree_view, count);
8067       break;
8068     case GTK_MOVEMENT_DISPLAY_LINES:
8069       gtk_tree_view_move_cursor_up_down (tree_view, count);
8070       break;
8071     case GTK_MOVEMENT_PAGES:
8072       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8073       break;
8074     case GTK_MOVEMENT_BUFFER_ENDS:
8075       gtk_tree_view_move_cursor_start_end (tree_view, count);
8076       break;
8077     default:
8078       g_assert_not_reached ();
8079     }
8080
8081   tree_view->priv->ctrl_pressed = FALSE;
8082   tree_view->priv->shift_pressed = FALSE;
8083
8084   return TRUE;
8085 }
8086
8087 static void
8088 gtk_tree_view_put (GtkTreeView *tree_view,
8089                    GtkWidget   *child_widget,
8090                    /* in bin_window coordinates */
8091                    gint         x,
8092                    gint         y,
8093                    gint         width,
8094                    gint         height)
8095 {
8096   GtkTreeViewChild *child;
8097
8098   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8099   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8100
8101   child = g_slice_new (GtkTreeViewChild);
8102
8103   child->widget = child_widget;
8104   child->x = x;
8105   child->y = y;
8106   child->width = width;
8107   child->height = height;
8108
8109   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8110
8111   if (GTK_WIDGET_REALIZED (tree_view))
8112     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8113
8114   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8115 }
8116
8117 void
8118 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8119                                   GtkWidget   *widget,
8120                                   /* in tree coordinates */
8121                                   gint         x,
8122                                   gint         y,
8123                                   gint         width,
8124                                   gint         height)
8125 {
8126   GtkTreeViewChild *child = NULL;
8127   GList *list;
8128   GdkRectangle allocation;
8129
8130   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8131   g_return_if_fail (GTK_IS_WIDGET (widget));
8132
8133   for (list = tree_view->priv->children; list; list = list->next)
8134     {
8135       if (((GtkTreeViewChild *)list->data)->widget == widget)
8136         {
8137           child = list->data;
8138           break;
8139         }
8140     }
8141   if (child == NULL)
8142     return;
8143
8144   allocation.x = child->x = x;
8145   allocation.y = child->y = y;
8146   allocation.width = child->width = width;
8147   allocation.height = child->height = height;
8148
8149   if (GTK_WIDGET_REALIZED (widget))
8150     gtk_widget_size_allocate (widget, &allocation);
8151 }
8152
8153
8154 /* TreeModel Callbacks
8155  */
8156
8157 static void
8158 gtk_tree_view_row_changed (GtkTreeModel *model,
8159                            GtkTreePath  *path,
8160                            GtkTreeIter  *iter,
8161                            gpointer      data)
8162 {
8163   GtkTreeView *tree_view = (GtkTreeView *)data;
8164   GtkRBTree *tree;
8165   GtkRBNode *node;
8166   gboolean free_path = FALSE;
8167   GList *list;
8168   GtkTreePath *cursor_path;
8169
8170   g_return_if_fail (path != NULL || iter != NULL);
8171
8172   if (tree_view->priv->cursor != NULL)
8173     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8174   else
8175     cursor_path = NULL;
8176
8177   if (tree_view->priv->edited_column &&
8178       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8179     gtk_tree_view_stop_editing (tree_view, TRUE);
8180
8181   if (cursor_path != NULL)
8182     gtk_tree_path_free (cursor_path);
8183
8184   if (path == NULL)
8185     {
8186       path = gtk_tree_model_get_path (model, iter);
8187       free_path = TRUE;
8188     }
8189   else if (iter == NULL)
8190     gtk_tree_model_get_iter (model, iter, path);
8191
8192   if (_gtk_tree_view_find_node (tree_view,
8193                                 path,
8194                                 &tree,
8195                                 &node))
8196     /* We aren't actually showing the node */
8197     goto done;
8198
8199   if (tree == NULL)
8200     goto done;
8201
8202   if (tree_view->priv->fixed_height_mode
8203       && tree_view->priv->fixed_height >= 0)
8204     {
8205       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8206       if (GTK_WIDGET_REALIZED (tree_view))
8207         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8208     }
8209   else
8210     {
8211       _gtk_rbtree_node_mark_invalid (tree, node);
8212       for (list = tree_view->priv->columns; list; list = list->next)
8213         {
8214           GtkTreeViewColumn *column;
8215
8216           column = list->data;
8217           if (! column->visible)
8218             continue;
8219
8220           if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8221             {
8222               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8223             }
8224         }
8225     }
8226
8227  done:
8228   if (GTK_WIDGET_REALIZED (tree_view) && !tree_view->priv->fixed_height_mode)
8229     install_presize_handler (tree_view);
8230   if (free_path)
8231     gtk_tree_path_free (path);
8232 }
8233
8234 static void
8235 gtk_tree_view_row_inserted (GtkTreeModel *model,
8236                             GtkTreePath  *path,
8237                             GtkTreeIter  *iter,
8238                             gpointer      data)
8239 {
8240   GtkTreeView *tree_view = (GtkTreeView *) data;
8241   gint *indices;
8242   GtkRBTree *tmptree, *tree;
8243   GtkRBNode *tmpnode = NULL;
8244   gint depth;
8245   gint i = 0;
8246   gint height;
8247   gboolean free_path = FALSE;
8248   gboolean node_visible = TRUE;
8249
8250   g_return_if_fail (path != NULL || iter != NULL);
8251
8252   if (tree_view->priv->fixed_height_mode
8253       && tree_view->priv->fixed_height >= 0)
8254     height = tree_view->priv->fixed_height;
8255   else
8256     height = 0;
8257
8258   if (path == NULL)
8259     {
8260       path = gtk_tree_model_get_path (model, iter);
8261       free_path = TRUE;
8262     }
8263   else if (iter == NULL)
8264     gtk_tree_model_get_iter (model, iter, path);
8265
8266   if (tree_view->priv->tree == NULL)
8267     tree_view->priv->tree = _gtk_rbtree_new ();
8268
8269   tmptree = tree = tree_view->priv->tree;
8270
8271   /* Update all row-references */
8272   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8273   depth = gtk_tree_path_get_depth (path);
8274   indices = gtk_tree_path_get_indices (path);
8275
8276   /* First, find the parent tree */
8277   while (i < depth - 1)
8278     {
8279       if (tmptree == NULL)
8280         {
8281           /* We aren't showing the node */
8282           node_visible = FALSE;
8283           goto done;
8284         }
8285
8286       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
8287       if (tmpnode == NULL)
8288         {
8289           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8290                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8291                      "before the parent was inserted.");
8292           goto done;
8293         }
8294       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8295         {
8296           /* FIXME enforce correct behavior on model, probably */
8297           /* In theory, the model should have emitted has_child_toggled here.  We
8298            * try to catch it anyway, just to be safe, in case the model hasn't.
8299            */
8300           GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
8301                                                            tree,
8302                                                            tmpnode);
8303           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8304           gtk_tree_path_free (tmppath);
8305           goto done;
8306         }
8307
8308       tmptree = tmpnode->children;
8309       tree = tmptree;
8310       i++;
8311     }
8312
8313   if (tree == NULL)
8314     {
8315       node_visible = FALSE;
8316       goto done;
8317     }
8318
8319   /* ref the node */
8320   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8321   if (indices[depth - 1] == 0)
8322     {
8323       tmpnode = _gtk_rbtree_find_count (tree, 1);
8324       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8325     }
8326   else
8327     {
8328       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8329       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8330     }
8331
8332  done:
8333   if (height > 0)
8334     {
8335       if (tree)
8336         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8337
8338       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8339         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8340       else
8341         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8342     }
8343   else
8344     install_presize_handler (tree_view);
8345   if (free_path)
8346     gtk_tree_path_free (path);
8347 }
8348
8349 static void
8350 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8351                                      GtkTreePath  *path,
8352                                      GtkTreeIter  *iter,
8353                                      gpointer      data)
8354 {
8355   GtkTreeView *tree_view = (GtkTreeView *)data;
8356   GtkTreeIter real_iter;
8357   gboolean has_child;
8358   GtkRBTree *tree;
8359   GtkRBNode *node;
8360   gboolean free_path = FALSE;
8361
8362   g_return_if_fail (path != NULL || iter != NULL);
8363
8364   if (iter)
8365     real_iter = *iter;
8366
8367   if (path == NULL)
8368     {
8369       path = gtk_tree_model_get_path (model, iter);
8370       free_path = TRUE;
8371     }
8372   else if (iter == NULL)
8373     gtk_tree_model_get_iter (model, &real_iter, path);
8374
8375   if (_gtk_tree_view_find_node (tree_view,
8376                                 path,
8377                                 &tree,
8378                                 &node))
8379     /* We aren't actually showing the node */
8380     goto done;
8381
8382   if (tree == NULL)
8383     goto done;
8384
8385   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8386   /* Sanity check.
8387    */
8388   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8389     goto done;
8390
8391   if (has_child)
8392     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8393   else
8394     GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8395
8396   if (has_child && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
8397     {
8398       GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
8399       if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS))
8400         {
8401           GList *list;
8402
8403           for (list = tree_view->priv->columns; list; list = list->next)
8404             if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
8405               {
8406                 GTK_TREE_VIEW_COLUMN (list->data)->dirty = TRUE;
8407                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8408                 break;
8409               }
8410         }
8411       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8412     }
8413   else
8414     {
8415       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8416     }
8417
8418  done:
8419   if (free_path)
8420     gtk_tree_path_free (path);
8421 }
8422
8423 static void
8424 count_children_helper (GtkRBTree *tree,
8425                        GtkRBNode *node,
8426                        gpointer   data)
8427 {
8428   if (node->children)
8429     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8430   (*((gint *)data))++;
8431 }
8432
8433 static void
8434 check_selection_helper (GtkRBTree *tree,
8435                         GtkRBNode *node,
8436                         gpointer   data)
8437 {
8438   gint *value = (gint *)data;
8439
8440   *value = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8441
8442   if (node->children && !*value)
8443     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8444 }
8445
8446 static void
8447 gtk_tree_view_row_deleted (GtkTreeModel *model,
8448                            GtkTreePath  *path,
8449                            gpointer      data)
8450 {
8451   GtkTreeView *tree_view = (GtkTreeView *)data;
8452   GtkRBTree *tree;
8453   GtkRBNode *node;
8454   GList *list;
8455   gint selection_changed = FALSE;
8456
8457   g_return_if_fail (path != NULL);
8458
8459   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
8460
8461   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
8462     return;
8463
8464   if (tree == NULL)
8465     return;
8466
8467   /* check if the selection has been changed */
8468   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
8469                         check_selection_helper, &selection_changed);
8470
8471   for (list = tree_view->priv->columns; list; list = list->next)
8472     if (((GtkTreeViewColumn *)list->data)->visible &&
8473         ((GtkTreeViewColumn *)list->data)->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8474       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
8475
8476   /* Ensure we don't have a dangling pointer to a dead node */
8477   ensure_unprelighted (tree_view);
8478
8479   /* Cancel editting if we've started */
8480   gtk_tree_view_stop_editing (tree_view, TRUE);
8481
8482   /* If we have a node expanded/collapsed timeout, remove it */
8483   remove_expand_collapse_timeout (tree_view);
8484
8485   if (tree_view->priv->destroy_count_func)
8486     {
8487       gint child_count = 0;
8488       if (node->children)
8489         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
8490       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
8491     }
8492
8493   if (tree->root->count == 1)
8494     {
8495       if (tree_view->priv->tree == tree)
8496         tree_view->priv->tree = NULL;
8497
8498       _gtk_rbtree_remove (tree);
8499     }
8500   else
8501     {
8502       _gtk_rbtree_remove_node (tree, node);
8503     }
8504
8505   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
8506     {
8507       gtk_tree_row_reference_free (tree_view->priv->top_row);
8508       tree_view->priv->top_row = NULL;
8509     }
8510
8511   install_scroll_sync_handler (tree_view);
8512
8513   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8514
8515   if (selection_changed)
8516     g_signal_emit_by_name (tree_view->priv->selection, "changed");
8517 }
8518
8519 static void
8520 gtk_tree_view_rows_reordered (GtkTreeModel *model,
8521                               GtkTreePath  *parent,
8522                               GtkTreeIter  *iter,
8523                               gint         *new_order,
8524                               gpointer      data)
8525 {
8526   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
8527   GtkRBTree *tree;
8528   GtkRBNode *node;
8529   gint len;
8530
8531   len = gtk_tree_model_iter_n_children (model, iter);
8532
8533   if (len < 2)
8534     return;
8535
8536   gtk_tree_row_reference_reordered (G_OBJECT (data),
8537                                     parent,
8538                                     iter,
8539                                     new_order);
8540
8541   if (_gtk_tree_view_find_node (tree_view,
8542                                 parent,
8543                                 &tree,
8544                                 &node))
8545     return;
8546
8547   /* We need to special case the parent path */
8548   if (tree == NULL)
8549     tree = tree_view->priv->tree;
8550   else
8551     tree = node->children;
8552
8553   if (tree == NULL)
8554     return;
8555
8556   if (tree_view->priv->edited_column)
8557     gtk_tree_view_stop_editing (tree_view, TRUE);
8558
8559   /* we need to be unprelighted */
8560   ensure_unprelighted (tree_view);
8561
8562   /* clear the timeout */
8563   cancel_arrow_animation (tree_view);
8564
8565   _gtk_rbtree_reorder (tree, new_order, len);
8566
8567   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
8568
8569   gtk_tree_view_dy_to_top_row (tree_view);
8570 }
8571
8572
8573 /* Internal tree functions
8574  */
8575
8576
8577 static void
8578 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
8579                                      GtkRBTree         *tree,
8580                                      GtkTreeViewColumn *column,
8581                                      gint              *x1,
8582                                      gint              *x2)
8583 {
8584   GtkTreeViewColumn *tmp_column = NULL;
8585   gint total_width;
8586   GList *list;
8587   gboolean rtl;
8588
8589   if (x1)
8590     *x1 = 0;
8591
8592   if (x2)
8593     *x2 = 0;
8594
8595   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8596
8597   total_width = 0;
8598   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
8599        list;
8600        list = (rtl ? list->prev : list->next))
8601     {
8602       tmp_column = list->data;
8603
8604       if (tmp_column == column)
8605         break;
8606
8607       if (tmp_column->visible)
8608         total_width += tmp_column->width;
8609     }
8610
8611   if (tmp_column != column)
8612     {
8613       g_warning (G_STRLOC": passed-in column isn't in the tree");
8614       return;
8615     }
8616
8617   if (x1)
8618     *x1 = total_width;
8619
8620   if (x2)
8621     {
8622       if (column->visible)
8623         *x2 = total_width + column->width;
8624       else
8625         *x2 = total_width; /* width of 0 */
8626     }
8627 }
8628 static void
8629 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
8630                                 GtkRBTree   *tree,
8631                                 gint        *x1,
8632                                 gint        *x2)
8633 {
8634   gint x_offset = 0;
8635   GList *list;
8636   GtkTreeViewColumn *tmp_column = NULL;
8637   gint total_width;
8638   gboolean indent_expanders;
8639   gboolean rtl;
8640
8641   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8642
8643   total_width = 0;
8644   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
8645        list;
8646        list = (rtl ? list->prev : list->next))
8647     {
8648       tmp_column = list->data;
8649
8650       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
8651         {
8652           if (rtl)
8653             x_offset = total_width + tmp_column->width - tree_view->priv->expander_size;
8654           else
8655             x_offset = total_width;
8656           break;
8657         }
8658
8659       if (tmp_column->visible)
8660         total_width += tmp_column->width;
8661     }
8662
8663   gtk_widget_style_get (GTK_WIDGET (tree_view),
8664                         "indent-expanders", &indent_expanders,
8665                         NULL);
8666
8667   if (indent_expanders)
8668     {
8669       if (rtl)
8670         x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
8671       else
8672         x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
8673     }
8674
8675   *x1 = x_offset;
8676
8677   if (tmp_column && tmp_column->visible)
8678     /* +1 because x2 isn't included in the range. */
8679     *x2 = *x1 + tree_view->priv->expander_size + 1;
8680   else
8681     *x2 = *x1;
8682 }
8683
8684 static void
8685 gtk_tree_view_build_tree (GtkTreeView *tree_view,
8686                           GtkRBTree   *tree,
8687                           GtkTreeIter *iter,
8688                           gint         depth,
8689                           gboolean     recurse)
8690 {
8691   GtkRBNode *temp = NULL;
8692   GtkTreePath *path = NULL;
8693   gboolean is_list = GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST);
8694
8695   do
8696     {
8697       gtk_tree_model_ref_node (tree_view->priv->model, iter);
8698       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
8699
8700       if (tree_view->priv->fixed_height > 0)
8701         {
8702           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
8703             {
8704               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
8705               _gtk_rbtree_node_mark_valid (tree, temp);
8706             }
8707         }
8708
8709       if (is_list)
8710         continue;
8711
8712       if (recurse)
8713         {
8714           GtkTreeIter child;
8715
8716           if (!path)
8717             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
8718           else
8719             gtk_tree_path_next (path);
8720
8721           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
8722             {
8723               gboolean expand;
8724
8725               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
8726
8727               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
8728                   && !expand)
8729                 {
8730                   temp->children = _gtk_rbtree_new ();
8731                   temp->children->parent_tree = tree;
8732                   temp->children->parent_node = temp;
8733                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
8734                 }
8735             }
8736         }
8737
8738       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
8739         {
8740           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
8741             temp->flags ^= GTK_RBNODE_IS_PARENT;
8742         }
8743     }
8744   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
8745
8746   if (path)
8747     gtk_tree_path_free (path);
8748 }
8749
8750 /* If height is non-NULL, then we set it to be the new height.  if it's all
8751  * dirty, then height is -1.  We know we'll remeasure dirty rows, anyways.
8752  */
8753 static gboolean
8754 gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view,
8755                                    GtkTreeIter *iter,
8756                                    gint         depth,
8757                                    gint        *height,
8758                                    GtkRBNode   *node)
8759 {
8760   GtkTreeViewColumn *column;
8761   GList *list;
8762   gboolean retval = FALSE;
8763   gint tmpheight;
8764   gint horizontal_separator;
8765
8766   gtk_widget_style_get (GTK_WIDGET (tree_view),
8767                         "horizontal-separator", &horizontal_separator,
8768                         NULL);
8769
8770   if (height)
8771     *height = -1;
8772
8773   for (list = tree_view->priv->columns; list; list = list->next)
8774     {
8775       gint width;
8776       column = list->data;
8777       if (column->dirty == TRUE)
8778         continue;
8779       if (height == NULL && column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
8780         continue;
8781       if (!column->visible)
8782         continue;
8783
8784       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
8785                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
8786                                                node->children?TRUE:FALSE);
8787
8788       if (height)
8789         {
8790           gtk_tree_view_column_cell_get_size (column,
8791                                               NULL, NULL, NULL,
8792                                               &width, &tmpheight);
8793           *height = MAX (*height, tmpheight);
8794         }
8795       else
8796         {
8797           gtk_tree_view_column_cell_get_size (column,
8798                                               NULL, NULL, NULL,
8799                                               &width, NULL);
8800         }
8801
8802       if (gtk_tree_view_is_expander_column (tree_view, column))
8803         {
8804           int tmp = 0;
8805
8806           tmp = horizontal_separator + width + (depth - 1) * tree_view->priv->level_indentation;
8807           if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
8808             tmp += depth * tree_view->priv->expander_size;
8809
8810           if (tmp > column->requested_width)
8811             {
8812               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8813               retval = TRUE;
8814             }
8815         }
8816       else
8817         {
8818           if (horizontal_separator + width > column->requested_width)
8819             {
8820               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8821               retval = TRUE;
8822             }
8823         }
8824     }
8825
8826   return retval;
8827 }
8828
8829 static void
8830 gtk_tree_view_discover_dirty (GtkTreeView *tree_view,
8831                               GtkRBTree   *tree,
8832                               GtkTreeIter *iter,
8833                               gint         depth)
8834 {
8835   GtkRBNode *temp = tree->root;
8836   GtkTreeViewColumn *column;
8837   GList *list;
8838   GtkTreeIter child;
8839   gboolean is_all_dirty;
8840
8841   TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
8842
8843   while (temp->left != tree->nil)
8844     temp = temp->left;
8845
8846   do
8847     {
8848       TREE_VIEW_INTERNAL_ASSERT_VOID (temp != NULL);
8849       is_all_dirty = TRUE;
8850       for (list = tree_view->priv->columns; list; list = list->next)
8851         {
8852           column = list->data;
8853           if (column->dirty == FALSE)
8854             {
8855               is_all_dirty = FALSE;
8856               break;
8857             }
8858         }
8859
8860       if (is_all_dirty)
8861         return;
8862
8863       gtk_tree_view_discover_dirty_iter (tree_view,
8864                                          iter,
8865                                          depth,
8866                                          NULL,
8867                                          temp);
8868       if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter) &&
8869           temp->children != NULL)
8870         gtk_tree_view_discover_dirty (tree_view, temp->children, &child, depth + 1);
8871       temp = _gtk_rbtree_next (tree, temp);
8872     }
8873   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
8874 }
8875
8876
8877 /* Make sure the node is visible vertically */
8878 static void
8879 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
8880                                   GtkRBTree   *tree,
8881                                   GtkRBNode   *node)
8882 {
8883   gint node_dy, height;
8884   GtkTreePath *path = NULL;
8885
8886   if (!GTK_WIDGET_REALIZED (tree_view))
8887     return;
8888
8889   /* just return if the node is visible, avoiding a costly expose */
8890   node_dy = _gtk_rbtree_node_find_offset (tree, node);
8891   height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
8892   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
8893       && node_dy >= tree_view->priv->vadjustment->value
8894       && node_dy + height <= (tree_view->priv->vadjustment->value
8895                               + tree_view->priv->vadjustment->page_size))
8896     return;
8897
8898   path = _gtk_tree_view_find_path (tree_view, tree, node);
8899   if (path)
8900     {
8901       /* We process updates because we want to clear old selected items when we scroll.
8902        * if this is removed, we get a "selection streak" at the bottom. */
8903       gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
8904       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
8905       gtk_tree_path_free (path);
8906     }
8907 }
8908
8909 static void
8910 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
8911                                     GtkTreeViewColumn *column,
8912                                     gboolean           focus_to_cell)
8913 {
8914   gint x, width;
8915
8916   if (column == NULL)
8917     return;
8918
8919   x = column->button->allocation.x;
8920   width = column->button->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           g_assert (tmp_list->next->data);
9282           left = reorder->right_align = (reorder->right_column->button->allocation.x +
9283                                          reorder->right_column->button->allocation.width +
9284                                          ((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column->button->allocation.x)/2;
9285         }
9286       else
9287         {
9288           gint width;
9289
9290           gdk_drawable_get_size (tree_view->priv->header_window, &width, NULL);
9291           reorder->right_align = width + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9292         }
9293     }
9294 }
9295
9296 void
9297 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9298                                   GtkTreeViewColumn *column)
9299 {
9300   GdkEvent *send_event;
9301   GtkAllocation allocation;
9302   gint x, y, width, height;
9303   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9304   GdkDisplay *display = gdk_screen_get_display (screen);
9305
9306   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9307   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9308
9309   gtk_tree_view_set_column_drag_info (tree_view, column);
9310
9311   if (tree_view->priv->column_drag_info == NULL)
9312     return;
9313
9314   if (tree_view->priv->drag_window == NULL)
9315     {
9316       GdkWindowAttr attributes;
9317       guint attributes_mask;
9318
9319       attributes.window_type = GDK_WINDOW_CHILD;
9320       attributes.wclass = GDK_INPUT_OUTPUT;
9321       attributes.x = column->button->allocation.x;
9322       attributes.y = 0;
9323       attributes.width = column->button->allocation.width;
9324       attributes.height = column->button->allocation.height;
9325       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9326       attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
9327       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9328       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
9329
9330       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
9331                                                      &attributes,
9332                                                      attributes_mask);
9333       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
9334     }
9335
9336   gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
9337   gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
9338
9339   gtk_grab_remove (column->button);
9340
9341   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9342   send_event->crossing.send_event = TRUE;
9343   send_event->crossing.window = g_object_ref (GTK_BUTTON (column->button)->event_window);
9344   send_event->crossing.subwindow = NULL;
9345   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9346   send_event->crossing.time = GDK_CURRENT_TIME;
9347
9348   gtk_propagate_event (column->button, send_event);
9349   gdk_event_free (send_event);
9350
9351   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9352   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9353   send_event->button.send_event = TRUE;
9354   send_event->button.time = GDK_CURRENT_TIME;
9355   send_event->button.x = -1;
9356   send_event->button.y = -1;
9357   send_event->button.axes = NULL;
9358   send_event->button.state = 0;
9359   send_event->button.button = 1;
9360   send_event->button.device = gdk_display_get_core_pointer (display);
9361   send_event->button.x_root = 0;
9362   send_event->button.y_root = 0;
9363
9364   gtk_propagate_event (column->button, send_event);
9365   gdk_event_free (send_event);
9366
9367   /* Kids, don't try this at home */
9368   g_object_ref (column->button);
9369   gtk_container_remove (GTK_CONTAINER (tree_view), column->button);
9370   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
9371   gtk_widget_set_parent (column->button, GTK_WIDGET (tree_view));
9372   g_object_unref (column->button);
9373
9374   tree_view->priv->drag_column_x = column->button->allocation.x;
9375   allocation = column->button->allocation;
9376   allocation.x = 0;
9377   gtk_widget_size_allocate (column->button, &allocation);
9378   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
9379
9380   tree_view->priv->drag_column = column;
9381   gdk_window_show (tree_view->priv->drag_window);
9382
9383   gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
9384   gdk_drawable_get_size (tree_view->priv->header_window, &width, &height);
9385
9386   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9387   while (gtk_events_pending ())
9388     gtk_main_iteration ();
9389
9390   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG);
9391   gdk_pointer_grab (tree_view->priv->drag_window,
9392                     FALSE,
9393                     GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9394                     NULL, NULL, GDK_CURRENT_TIME);
9395   gdk_keyboard_grab (tree_view->priv->drag_window,
9396                      FALSE,
9397                      GDK_CURRENT_TIME);
9398 }
9399
9400 static void
9401 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9402                                 GtkRBTree          *tree,
9403                                 GtkRBNode          *node,
9404                                 const GdkRectangle *clip_rect)
9405 {
9406   GdkRectangle rect;
9407
9408   if (!GTK_WIDGET_REALIZED (tree_view))
9409     return;
9410
9411   rect.x = 0;
9412   rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width));
9413
9414   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
9415   rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
9416
9417   if (clip_rect)
9418     {
9419       GdkRectangle new_rect;
9420
9421       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9422
9423       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9424     }
9425   else
9426     {
9427       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9428     }
9429 }
9430
9431 void
9432 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9433                                 GtkRBTree          *tree,
9434                                 GtkRBNode          *node,
9435                                 const GdkRectangle *clip_rect)
9436 {
9437   GdkRectangle rect;
9438
9439   if (!GTK_WIDGET_REALIZED (tree_view))
9440     return;
9441
9442   rect.x = 0;
9443   rect.width = MAX (tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width);
9444
9445   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
9446   rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
9447
9448   if (clip_rect)
9449     {
9450       GdkRectangle new_rect;
9451
9452       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9453
9454       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9455     }
9456   else
9457     {
9458       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9459     }
9460 }
9461
9462 static void
9463 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
9464                                GtkTreePath        *path,
9465                                const GdkRectangle *clip_rect)
9466 {
9467   GtkRBTree *tree = NULL;
9468   GtkRBNode *node = NULL;
9469
9470   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
9471
9472   if (tree)
9473     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
9474 }
9475
9476 /* x and y are the mouse position
9477  */
9478 static void
9479 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
9480                           GtkRBTree   *tree,
9481                           GtkRBNode   *node,
9482                           /* in bin_window coordinates */
9483                           gint         x,
9484                           gint         y)
9485 {
9486   GdkRectangle area;
9487   GtkStateType state;
9488   GtkWidget *widget;
9489   gint x_offset = 0;
9490   gint x2;
9491   gint vertical_separator;
9492   gint expander_size;
9493   GtkExpanderStyle expander_style;
9494
9495   gtk_widget_style_get (GTK_WIDGET (tree_view),
9496                         "vertical-separator", &vertical_separator,
9497                         NULL);
9498   expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
9499
9500   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
9501     return;
9502
9503   widget = GTK_WIDGET (tree_view);
9504
9505   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
9506
9507   area.x = x_offset;
9508   area.y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
9509   area.width = expander_size + 2;
9510   area.height = MAX (CELL_HEIGHT (node, vertical_separator), (expander_size - vertical_separator));
9511
9512   if (GTK_WIDGET_STATE (tree_view) == GTK_STATE_INSENSITIVE)
9513     {
9514       state = GTK_STATE_INSENSITIVE;
9515     }
9516   else if (node == tree_view->priv->button_pressed_node)
9517     {
9518       if (x >= area.x && x <= (area.x + area.width) &&
9519           y >= area.y && y <= (area.y + area.height))
9520         state = GTK_STATE_ACTIVE;
9521       else
9522         state = GTK_STATE_NORMAL;
9523     }
9524   else
9525     {
9526       if (node == tree_view->priv->prelight_node &&
9527           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
9528         state = GTK_STATE_PRELIGHT;
9529       else
9530         state = GTK_STATE_NORMAL;
9531     }
9532
9533   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
9534     expander_style = GTK_EXPANDER_SEMI_EXPANDED;
9535   else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
9536     expander_style = GTK_EXPANDER_SEMI_COLLAPSED;
9537   else if (node->children != NULL)
9538     expander_style = GTK_EXPANDER_EXPANDED;
9539   else
9540     expander_style = GTK_EXPANDER_COLLAPSED;
9541
9542   gtk_paint_expander (widget->style,
9543                       tree_view->priv->bin_window,
9544                       state,
9545                       &area,
9546                       widget,
9547                       "treeview",
9548                       area.x + area.width / 2,
9549                       area.y + area.height / 2,
9550                       expander_style);
9551 }
9552
9553 static void
9554 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
9555
9556 {
9557   GtkTreePath *cursor_path;
9558
9559   if ((tree_view->priv->tree == NULL) ||
9560       (! GTK_WIDGET_REALIZED (tree_view)))
9561     return;
9562
9563   cursor_path = NULL;
9564   if (tree_view->priv->cursor)
9565     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9566
9567   if (cursor_path == NULL)
9568     {
9569       /* Consult the selection before defaulting to the
9570        * first focusable element
9571        */
9572       GList *selected_rows;
9573       GtkTreeModel *model;
9574       GtkTreeSelection *selection;
9575
9576       selection = gtk_tree_view_get_selection (tree_view);
9577       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
9578
9579       if (selected_rows)
9580         {
9581           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
9582           g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
9583           g_list_free (selected_rows);
9584         }
9585       else
9586         {
9587           cursor_path = gtk_tree_path_new_first ();
9588           search_first_focusable_path (tree_view, &cursor_path,
9589                                        TRUE, NULL, NULL);
9590         }
9591
9592       gtk_tree_row_reference_free (tree_view->priv->cursor);
9593       tree_view->priv->cursor = NULL;
9594
9595       if (cursor_path)
9596         {
9597           if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE)
9598             gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE);
9599           else
9600             gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
9601         }
9602     }
9603
9604   if (cursor_path)
9605     {
9606       GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
9607
9608       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
9609       gtk_tree_path_free (cursor_path);
9610
9611       if (tree_view->priv->focus_column == NULL)
9612         {
9613           GList *list;
9614           for (list = tree_view->priv->columns; list; list = list->next)
9615             {
9616               if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
9617                 {
9618                   tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
9619                   break;
9620                 }
9621             }
9622         }
9623     }
9624 }
9625
9626 static void
9627 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
9628                                    gint         count)
9629 {
9630   gint selection_count;
9631   GtkRBTree *cursor_tree = NULL;
9632   GtkRBNode *cursor_node = NULL;
9633   GtkRBTree *new_cursor_tree = NULL;
9634   GtkRBNode *new_cursor_node = NULL;
9635   GtkTreePath *cursor_path = NULL;
9636   gboolean grab_focus = TRUE;
9637   gboolean selectable;
9638
9639   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
9640     return;
9641
9642   cursor_path = NULL;
9643   if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
9644     /* FIXME: we lost the cursor; should we get the first? */
9645     return;
9646
9647   cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9648   _gtk_tree_view_find_node (tree_view, cursor_path,
9649                             &cursor_tree, &cursor_node);
9650
9651   if (cursor_tree == NULL)
9652     /* FIXME: we lost the cursor; should we get the first? */
9653     return;
9654
9655   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
9656   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
9657                                                       cursor_node,
9658                                                       cursor_path);
9659
9660   if (selection_count == 0
9661       && tree_view->priv->selection->type != GTK_SELECTION_NONE
9662       && !tree_view->priv->ctrl_pressed
9663       && selectable)
9664     {
9665       /* Don't move the cursor, but just select the current node */
9666       new_cursor_tree = cursor_tree;
9667       new_cursor_node = cursor_node;
9668     }
9669   else
9670     {
9671       if (count == -1)
9672         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
9673                                &new_cursor_tree, &new_cursor_node);
9674       else
9675         _gtk_rbtree_next_full (cursor_tree, cursor_node,
9676                                &new_cursor_tree, &new_cursor_node);
9677     }
9678
9679   gtk_tree_path_free (cursor_path);
9680
9681   if (new_cursor_node)
9682     {
9683       cursor_path = _gtk_tree_view_find_path (tree_view,
9684                                               new_cursor_tree, new_cursor_node);
9685
9686       search_first_focusable_path (tree_view, &cursor_path,
9687                                    (count != -1),
9688                                    &new_cursor_tree,
9689                                    &new_cursor_node);
9690
9691       if (cursor_path)
9692         gtk_tree_path_free (cursor_path);
9693     }
9694
9695   /*
9696    * If the list has only one item and multi-selection is set then select
9697    * the row (if not yet selected).
9698    */
9699   if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE &&
9700       new_cursor_node == NULL)
9701     {
9702       if (count == -1)
9703         _gtk_rbtree_next_full (cursor_tree, cursor_node,
9704                                &new_cursor_tree, &new_cursor_node);
9705       else
9706         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
9707                                &new_cursor_tree, &new_cursor_node);
9708
9709       if (new_cursor_node == NULL
9710           && !GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_SELECTED))
9711         {
9712           new_cursor_node = cursor_node;
9713           new_cursor_tree = cursor_tree;
9714         }
9715       else
9716         {
9717           new_cursor_node = NULL;
9718         }
9719     }
9720
9721   if (new_cursor_node)
9722     {
9723       cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node);
9724       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
9725       gtk_tree_path_free (cursor_path);
9726     }
9727   else
9728     {
9729       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
9730
9731       if (!tree_view->priv->shift_pressed)
9732         {
9733           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
9734                                           count < 0 ?
9735                                           GTK_DIR_UP : GTK_DIR_DOWN))
9736             {
9737               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
9738
9739               if (toplevel)
9740                 gtk_widget_child_focus (toplevel,
9741                                         count < 0 ?
9742                                         GTK_DIR_TAB_BACKWARD :
9743                                         GTK_DIR_TAB_FORWARD);
9744
9745               grab_focus = FALSE;
9746             }
9747         }
9748       else
9749         {
9750           gtk_widget_error_bell (GTK_WIDGET (tree_view));
9751         }
9752     }
9753
9754   if (grab_focus)
9755     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9756 }
9757
9758 static void
9759 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
9760                                         gint         count)
9761 {
9762   GtkRBTree *cursor_tree = NULL;
9763   GtkRBNode *cursor_node = NULL;
9764   GtkTreePath *old_cursor_path = NULL;
9765   GtkTreePath *cursor_path = NULL;
9766   GtkRBTree *start_cursor_tree = NULL;
9767   GtkRBNode *start_cursor_node = NULL;
9768   gint y;
9769   gint window_y;
9770   gint vertical_separator;
9771
9772   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
9773     return;
9774
9775   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
9776     old_cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9777   else
9778     /* This is sorta weird.  Focus in should give us a cursor */
9779     return;
9780
9781   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
9782   _gtk_tree_view_find_node (tree_view, old_cursor_path,
9783                             &cursor_tree, &cursor_node);
9784
9785   if (cursor_tree == NULL)
9786     {
9787       /* FIXME: we lost the cursor.  Should we try to get one? */
9788       gtk_tree_path_free (old_cursor_path);
9789       return;
9790     }
9791   g_return_if_fail (cursor_node != NULL);
9792
9793   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
9794   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
9795   y += tree_view->priv->cursor_offset;
9796   y += count * (int)tree_view->priv->vadjustment->page_increment;
9797   y = CLAMP (y, (gint)tree_view->priv->vadjustment->lower,  (gint)tree_view->priv->vadjustment->upper - vertical_separator);
9798
9799   if (y >= tree_view->priv->height)
9800     y = tree_view->priv->height - 1;
9801
9802   tree_view->priv->cursor_offset =
9803     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
9804                              &cursor_tree, &cursor_node);
9805
9806   if (tree_view->priv->cursor_offset > BACKGROUND_HEIGHT (cursor_node))
9807     {
9808       _gtk_rbtree_next_full (cursor_tree, cursor_node,
9809                              &cursor_tree, &cursor_node);
9810       tree_view->priv->cursor_offset -= BACKGROUND_HEIGHT (cursor_node);
9811     }
9812
9813   y -= tree_view->priv->cursor_offset;
9814   cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
9815
9816   start_cursor_tree = cursor_tree;
9817   start_cursor_node = cursor_node;
9818
9819   if (! search_first_focusable_path (tree_view, &cursor_path,
9820                                      (count != -1),
9821                                      &cursor_tree, &cursor_node))
9822     {
9823       /* It looks like we reached the end of the view without finding
9824        * a focusable row.  We will step backwards to find the last
9825        * focusable row.
9826        */
9827       cursor_tree = start_cursor_tree;
9828       cursor_node = start_cursor_node;
9829       cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
9830
9831       search_first_focusable_path (tree_view, &cursor_path,
9832                                    (count == -1),
9833                                    &cursor_tree, &cursor_node);
9834     }
9835
9836   if (!cursor_path)
9837     goto cleanup;
9838
9839   /* update y */
9840   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
9841
9842   gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
9843
9844   y -= window_y;
9845   gtk_tree_view_scroll_to_point (tree_view, -1, y);
9846   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
9847   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
9848
9849   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
9850     gtk_widget_error_bell (GTK_WIDGET (tree_view));
9851
9852 cleanup:
9853   gtk_tree_path_free (old_cursor_path);
9854   gtk_tree_path_free (cursor_path);
9855 }
9856
9857 static void
9858 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
9859                                       gint         count)
9860 {
9861   GtkRBTree *cursor_tree = NULL;
9862   GtkRBNode *cursor_node = NULL;
9863   GtkTreePath *cursor_path = NULL;
9864   GtkTreeViewColumn *column;
9865   GtkTreeIter iter;
9866   GList *list;
9867   gboolean found_column = FALSE;
9868   gboolean rtl;
9869
9870   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9871
9872   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
9873     return;
9874
9875   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
9876     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9877   else
9878     return;
9879
9880   _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node);
9881   if (cursor_tree == NULL)
9882     return;
9883   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
9884     {
9885       gtk_tree_path_free (cursor_path);
9886       return;
9887     }
9888   gtk_tree_path_free (cursor_path);
9889
9890   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
9891   if (tree_view->priv->focus_column)
9892     {
9893       for (; list; list = (rtl ? list->prev : list->next))
9894         {
9895           if (list->data == tree_view->priv->focus_column)
9896             break;
9897         }
9898     }
9899
9900   while (list)
9901     {
9902       gboolean left, right;
9903
9904       column = list->data;
9905       if (column->visible == FALSE)
9906         goto loop_end;
9907
9908       gtk_tree_view_column_cell_set_cell_data (column,
9909                                                tree_view->priv->model,
9910                                                &iter,
9911                                                GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
9912                                                cursor_node->children?TRUE:FALSE);
9913
9914       if (rtl)
9915         {
9916           right = list->prev ? TRUE : FALSE;
9917           left = list->next ? TRUE : FALSE;
9918         }
9919       else
9920         {
9921           left = list->prev ? TRUE : FALSE;
9922           right = list->next ? TRUE : FALSE;
9923         }
9924
9925       if (_gtk_tree_view_column_cell_focus (column, count, left, right))
9926         {
9927           tree_view->priv->focus_column = column;
9928           found_column = TRUE;
9929           break;
9930         }
9931     loop_end:
9932       if (count == 1)
9933         list = rtl ? list->prev : list->next;
9934       else
9935         list = rtl ? list->next : list->prev;
9936     }
9937
9938   if (found_column)
9939     {
9940       if (!gtk_tree_view_has_special_cell (tree_view))
9941         _gtk_tree_view_queue_draw_node (tree_view,
9942                                         cursor_tree,
9943                                         cursor_node,
9944                                         NULL);
9945       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
9946     }
9947   else
9948     {
9949       gtk_widget_error_bell (GTK_WIDGET (tree_view));
9950     }
9951
9952   gtk_tree_view_clamp_column_visible (tree_view,
9953                                       tree_view->priv->focus_column, TRUE);
9954 }
9955
9956 static void
9957 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
9958                                      gint         count)
9959 {
9960   GtkRBTree *cursor_tree;
9961   GtkRBNode *cursor_node;
9962   GtkTreePath *path;
9963   GtkTreePath *old_path;
9964
9965   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
9966     return;
9967
9968   g_return_if_fail (tree_view->priv->tree != NULL);
9969
9970   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
9971
9972   cursor_tree = tree_view->priv->tree;
9973   cursor_node = cursor_tree->root;
9974
9975   if (count == -1)
9976     {
9977       while (cursor_node && cursor_node->left != cursor_tree->nil)
9978         cursor_node = cursor_node->left;
9979
9980       /* Now go forward to find the first focusable row. */
9981       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
9982       search_first_focusable_path (tree_view, &path,
9983                                    TRUE, &cursor_tree, &cursor_node);
9984     }
9985   else
9986     {
9987       do
9988         {
9989           while (cursor_node && cursor_node->right != cursor_tree->nil)
9990             cursor_node = cursor_node->right;
9991           if (cursor_node->children == NULL)
9992             break;
9993
9994           cursor_tree = cursor_node->children;
9995           cursor_node = cursor_tree->root;
9996         }
9997       while (1);
9998
9999       /* Now go backwards to find last focusable row. */
10000       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10001       search_first_focusable_path (tree_view, &path,
10002                                    FALSE, &cursor_tree, &cursor_node);
10003     }
10004
10005   if (!path)
10006     goto cleanup;
10007
10008   if (gtk_tree_path_compare (old_path, path))
10009     {
10010       gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
10011     }
10012   else
10013     {
10014       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10015     }
10016
10017 cleanup:
10018   gtk_tree_path_free (old_path);
10019   gtk_tree_path_free (path);
10020 }
10021
10022 static gboolean
10023 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10024 {
10025   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
10026     return FALSE;
10027
10028   if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
10029     return FALSE;
10030
10031   gtk_tree_selection_select_all (tree_view->priv->selection);
10032
10033   return TRUE;
10034 }
10035
10036 static gboolean
10037 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
10038 {
10039   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
10040     return FALSE;
10041
10042   if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
10043     return FALSE;
10044
10045   gtk_tree_selection_unselect_all (tree_view->priv->selection);
10046
10047   return TRUE;
10048 }
10049
10050 static gboolean
10051 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10052                                       gboolean     start_editing)
10053 {
10054   GtkRBTree *new_tree = NULL;
10055   GtkRBNode *new_node = NULL;
10056   GtkRBTree *cursor_tree = NULL;
10057   GtkRBNode *cursor_node = NULL;
10058   GtkTreePath *cursor_path = NULL;
10059   GtkTreeSelectMode mode = 0;
10060
10061   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
10062     return FALSE;
10063
10064   if (tree_view->priv->cursor)
10065     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10066
10067   if (cursor_path == NULL)
10068     return FALSE;
10069
10070   _gtk_tree_view_find_node (tree_view, cursor_path,
10071                             &cursor_tree, &cursor_node);
10072
10073   if (cursor_tree == NULL)
10074     {
10075       gtk_tree_path_free (cursor_path);
10076       return FALSE;
10077     }
10078
10079   if (!tree_view->priv->shift_pressed && start_editing &&
10080       tree_view->priv->focus_column)
10081     {
10082       if (gtk_tree_view_start_editing (tree_view, cursor_path))
10083         {
10084           gtk_tree_path_free (cursor_path);
10085           return TRUE;
10086         }
10087     }
10088
10089   if (tree_view->priv->ctrl_pressed)
10090     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10091   if (tree_view->priv->shift_pressed)
10092     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10093
10094   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10095                                             cursor_node,
10096                                             cursor_tree,
10097                                             cursor_path,
10098                                             mode,
10099                                             FALSE);
10100
10101   /* We bail out if the original (tree, node) don't exist anymore after
10102    * handling the selection-changed callback.  We do return TRUE because
10103    * the key press has been handled at this point.
10104    */
10105   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10106
10107   if (cursor_tree != new_tree || cursor_node != new_node)
10108     return FALSE;
10109
10110   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10111
10112   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10113   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10114
10115   if (!tree_view->priv->shift_pressed)
10116     gtk_tree_view_row_activated (tree_view, cursor_path,
10117                                  tree_view->priv->focus_column);
10118
10119   gtk_tree_path_free (cursor_path);
10120
10121   return TRUE;
10122 }
10123
10124 static gboolean
10125 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10126 {
10127   GtkRBTree *new_tree = NULL;
10128   GtkRBNode *new_node = NULL;
10129   GtkRBTree *cursor_tree = NULL;
10130   GtkRBNode *cursor_node = NULL;
10131   GtkTreePath *cursor_path = NULL;
10132
10133   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
10134     return FALSE;
10135
10136   cursor_path = NULL;
10137   if (tree_view->priv->cursor)
10138     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10139
10140   if (cursor_path == NULL)
10141     return FALSE;
10142
10143   _gtk_tree_view_find_node (tree_view, cursor_path,
10144                             &cursor_tree, &cursor_node);
10145   if (cursor_tree == NULL)
10146     {
10147       gtk_tree_path_free (cursor_path);
10148       return FALSE;
10149     }
10150
10151   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10152                                             cursor_node,
10153                                             cursor_tree,
10154                                             cursor_path,
10155                                             GTK_TREE_SELECT_MODE_TOGGLE,
10156                                             FALSE);
10157
10158   /* We bail out if the original (tree, node) don't exist anymore after
10159    * handling the selection-changed callback.  We do return TRUE because
10160    * the key press has been handled at this point.
10161    */
10162   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10163
10164   if (cursor_tree != new_tree || cursor_node != new_node)
10165     return FALSE;
10166
10167   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10168
10169   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10170   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10171   gtk_tree_path_free (cursor_path);
10172
10173   return TRUE;
10174 }
10175
10176 static gboolean
10177 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10178                                                gboolean     logical,
10179                                                gboolean     expand,
10180                                                gboolean     open_all)
10181 {
10182   GtkTreePath *cursor_path = NULL;
10183   GtkRBTree *tree;
10184   GtkRBNode *node;
10185
10186   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
10187     return FALSE;
10188
10189   cursor_path = NULL;
10190   if (tree_view->priv->cursor)
10191     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10192
10193   if (cursor_path == NULL)
10194     return FALSE;
10195
10196   if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node))
10197     return FALSE;
10198
10199   /* Don't handle the event if we aren't an expander */
10200   if (!((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT))
10201     return FALSE;
10202
10203   if (!logical
10204       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10205     expand = !expand;
10206
10207   if (expand)
10208     gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE);
10209   else
10210     gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE);
10211
10212   gtk_tree_path_free (cursor_path);
10213
10214   return TRUE;
10215 }
10216
10217 static gboolean
10218 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10219 {
10220   GtkRBTree *cursor_tree = NULL;
10221   GtkRBNode *cursor_node = NULL;
10222   GtkTreePath *cursor_path = NULL;
10223   GdkModifierType state;
10224
10225   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
10226     return FALSE;
10227
10228   cursor_path = NULL;
10229   if (tree_view->priv->cursor)
10230     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10231
10232   if (cursor_path == NULL)
10233     return FALSE;
10234
10235   _gtk_tree_view_find_node (tree_view, cursor_path,
10236                             &cursor_tree, &cursor_node);
10237   if (cursor_tree == NULL)
10238     {
10239       gtk_tree_path_free (cursor_path);
10240       return FALSE;
10241     }
10242
10243   if (gtk_get_current_event_state (&state))
10244     {
10245       if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
10246         tree_view->priv->ctrl_pressed = TRUE;
10247     }
10248
10249   if (cursor_tree->parent_node)
10250     {
10251       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10252       cursor_node = cursor_tree->parent_node;
10253       cursor_tree = cursor_tree->parent_tree;
10254
10255       gtk_tree_path_up (cursor_path);
10256
10257       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10258     }
10259
10260   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10261
10262   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10263   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10264   gtk_tree_path_free (cursor_path);
10265
10266   tree_view->priv->ctrl_pressed = FALSE;
10267
10268   return TRUE;
10269 }
10270 static gboolean
10271 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10272 {
10273   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view);
10274   tree_view->priv->typeselect_flush_timeout = 0;
10275
10276   return FALSE;
10277 }
10278
10279 /* Cut and paste from gtkwindow.c */
10280 static void
10281 send_focus_change (GtkWidget *widget,
10282                    gboolean   in)
10283 {
10284   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10285
10286   g_object_ref (widget);
10287
10288  if (in)
10289     GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
10290   else
10291     GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
10292
10293   fevent->focus_change.type = GDK_FOCUS_CHANGE;
10294   fevent->focus_change.window = g_object_ref (widget->window);
10295   fevent->focus_change.in = in;
10296
10297   gtk_widget_event (widget, fevent);
10298
10299   g_object_notify (G_OBJECT (widget), "has-focus");
10300
10301   g_object_unref (widget);
10302   gdk_event_free (fevent);
10303 }
10304
10305 static void
10306 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10307 {
10308   GtkWidget *frame, *vbox, *toplevel;
10309   GdkScreen *screen;
10310
10311   if (tree_view->priv->search_custom_entry_set)
10312     return;
10313
10314   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10315   screen = gtk_widget_get_screen (tree_view);
10316
10317    if (tree_view->priv->search_window != NULL)
10318      {
10319        if (GTK_WINDOW (toplevel)->group)
10320          gtk_window_group_add_window (GTK_WINDOW (toplevel)->group,
10321                                       GTK_WINDOW (tree_view->priv->search_window));
10322        else if (GTK_WINDOW (tree_view->priv->search_window)->group)
10323          gtk_window_group_remove_window (GTK_WINDOW (tree_view->priv->search_window)->group,
10324                                          GTK_WINDOW (tree_view->priv->search_window));
10325        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10326        return;
10327      }
10328
10329   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10330   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10331
10332   if (GTK_WINDOW (toplevel)->group)
10333     gtk_window_group_add_window (GTK_WINDOW (toplevel)->group,
10334                                  GTK_WINDOW (tree_view->priv->search_window));
10335
10336   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10337                             GDK_WINDOW_TYPE_HINT_UTILITY);
10338   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10339   g_signal_connect (tree_view->priv->search_window, "delete-event",
10340                     G_CALLBACK (gtk_tree_view_search_delete_event),
10341                     tree_view);
10342   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10343                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10344                     tree_view);
10345   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10346                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10347                     tree_view);
10348   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10349                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10350                     tree_view);
10351
10352   frame = gtk_frame_new (NULL);
10353   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10354   gtk_widget_show (frame);
10355   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10356
10357   vbox = gtk_vbox_new (FALSE, 0);
10358   gtk_widget_show (vbox);
10359   gtk_container_add (GTK_CONTAINER (frame), vbox);
10360   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
10361
10362   /* add entry */
10363   tree_view->priv->search_entry = gtk_entry_new ();
10364   gtk_widget_show (tree_view->priv->search_entry);
10365   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
10366                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
10367                     tree_view);
10368   g_signal_connect (tree_view->priv->search_entry,
10369                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
10370                     tree_view);
10371   g_signal_connect (GTK_ENTRY (tree_view->priv->search_entry)->im_context,
10372                     "preedit-changed",
10373                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
10374                     tree_view);
10375   gtk_container_add (GTK_CONTAINER (vbox),
10376                      tree_view->priv->search_entry);
10377
10378   gtk_widget_realize (tree_view->priv->search_entry);
10379 }
10380
10381 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
10382  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
10383  */
10384 static gboolean
10385 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
10386                                              gboolean     keybinding)
10387 {
10388   /* We only start interactive search if we have focus or the columns
10389    * have focus.  If one of our children have focus, we don't want to
10390    * start the search.
10391    */
10392   GList *list;
10393   gboolean found_focus = FALSE;
10394   GtkWidgetClass *entry_parent_class;
10395
10396   if (!tree_view->priv->enable_search && !keybinding)
10397     return FALSE;
10398
10399   if (tree_view->priv->search_custom_entry_set)
10400     return FALSE;
10401
10402   if (tree_view->priv->search_window != NULL &&
10403       GTK_WIDGET_VISIBLE (tree_view->priv->search_window))
10404     return TRUE;
10405
10406   for (list = tree_view->priv->columns; list; list = list->next)
10407     {
10408       GtkTreeViewColumn *column;
10409
10410       column = list->data;
10411       if (! column->visible)
10412         continue;
10413
10414       if (GTK_WIDGET_HAS_FOCUS (column->button))
10415         {
10416           found_focus = TRUE;
10417           break;
10418         }
10419     }
10420
10421   if (GTK_WIDGET_HAS_FOCUS (tree_view))
10422     found_focus = TRUE;
10423
10424   if (!found_focus)
10425     return FALSE;
10426
10427   if (tree_view->priv->search_column < 0)
10428     return FALSE;
10429
10430   gtk_tree_view_ensure_interactive_directory (tree_view);
10431
10432   if (keybinding)
10433     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
10434
10435   /* done, show it */
10436   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
10437   gtk_widget_show (tree_view->priv->search_window);
10438   if (tree_view->priv->search_entry_changed_id == 0)
10439     {
10440       tree_view->priv->search_entry_changed_id =
10441         g_signal_connect (tree_view->priv->search_entry, "changed",
10442                           G_CALLBACK (gtk_tree_view_search_init),
10443                           tree_view);
10444     }
10445
10446   tree_view->priv->typeselect_flush_timeout =
10447     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
10448                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
10449                    tree_view);
10450
10451   /* Grab focus will select all the text.  We don't want that to happen, so we
10452    * call the parent instance and bypass the selection change.  This is probably
10453    * really non-kosher. */
10454   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
10455   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
10456
10457   /* send focus-in event */
10458   send_focus_change (tree_view->priv->search_entry, TRUE);
10459
10460   /* search first matching iter */
10461   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
10462
10463   return TRUE;
10464 }
10465
10466 static gboolean
10467 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
10468 {
10469   return gtk_tree_view_real_start_interactive_search (tree_view, TRUE);
10470 }
10471
10472 /* this function returns the new width of the column being resized given
10473  * the column and x position of the cursor; the x cursor position is passed
10474  * in as a pointer and automagicly corrected if it's beyond min/max limits
10475  */
10476 static gint
10477 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
10478                                 gint       i,
10479                                 gint      *x)
10480 {
10481   GtkTreeViewColumn *column;
10482   gint width;
10483   gboolean rtl;
10484
10485   /* first translate the x position from widget->window
10486    * to clist->clist_window
10487    */
10488   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10489   column = g_list_nth (tree_view->priv->columns, i)->data;
10490   width = rtl ? (column->button->allocation.x + column->button->allocation.width - *x) : (*x - column->button->allocation.x);
10491
10492   /* Clamp down the value */
10493   if (column->min_width == -1)
10494     width = MAX (column->button->requisition.width,
10495                  width);
10496   else
10497     width = MAX (column->min_width,
10498                  width);
10499   if (column->max_width != -1)
10500     width = MIN (width, column->max_width);
10501
10502   *x = rtl ? (column->button->allocation.x + column->button->allocation.width - width) : (column->button->allocation.x + width);
10503
10504   return width;
10505 }
10506
10507
10508 /* FIXME this adjust_allocation is a big cut-and-paste from
10509  * GtkCList, needs to be some "official" way to do this
10510  * factored out.
10511  */
10512 typedef struct
10513 {
10514   GdkWindow *window;
10515   int dx;
10516   int dy;
10517 } ScrollData;
10518
10519 /* The window to which widget->window is relative */
10520 #define ALLOCATION_WINDOW(widget)               \
10521    (GTK_WIDGET_NO_WINDOW (widget) ?             \
10522     (widget)->window :                          \
10523      gdk_window_get_parent ((widget)->window))
10524
10525 static void
10526 adjust_allocation_recurse (GtkWidget *widget,
10527                            gpointer   data)
10528 {
10529   ScrollData *scroll_data = data;
10530
10531   /* Need to really size allocate instead of just poking
10532    * into widget->allocation if the widget is not realized.
10533    * FIXME someone figure out why this was.
10534    */
10535   if (!GTK_WIDGET_REALIZED (widget))
10536     {
10537       if (GTK_WIDGET_VISIBLE (widget))
10538         {
10539           GdkRectangle tmp_rectangle = widget->allocation;
10540           tmp_rectangle.x += scroll_data->dx;
10541           tmp_rectangle.y += scroll_data->dy;
10542
10543           gtk_widget_size_allocate (widget, &tmp_rectangle);
10544         }
10545     }
10546   else
10547     {
10548       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
10549         {
10550           widget->allocation.x += scroll_data->dx;
10551           widget->allocation.y += scroll_data->dy;
10552
10553           if (GTK_IS_CONTAINER (widget))
10554             gtk_container_forall (GTK_CONTAINER (widget),
10555                                   adjust_allocation_recurse,
10556                                   data);
10557         }
10558     }
10559 }
10560
10561 static void
10562 adjust_allocation (GtkWidget *widget,
10563                    int        dx,
10564                    int        dy)
10565 {
10566   ScrollData scroll_data;
10567
10568   if (GTK_WIDGET_REALIZED (widget))
10569     scroll_data.window = ALLOCATION_WINDOW (widget);
10570   else
10571     scroll_data.window = NULL;
10572
10573   scroll_data.dx = dx;
10574   scroll_data.dy = dy;
10575
10576   adjust_allocation_recurse (widget, &scroll_data);
10577 }
10578
10579 /* Callbacks */
10580 static void
10581 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
10582                                   GtkTreeView   *tree_view)
10583 {
10584   if (GTK_WIDGET_REALIZED (tree_view))
10585     {
10586       gint dy;
10587
10588       gdk_window_move (tree_view->priv->bin_window,
10589                        - tree_view->priv->hadjustment->value,
10590                        TREE_VIEW_HEADER_HEIGHT (tree_view));
10591       gdk_window_move (tree_view->priv->header_window,
10592                        - tree_view->priv->hadjustment->value,
10593                        0);
10594       dy = tree_view->priv->dy - (int) tree_view->priv->vadjustment->value;
10595       if (dy && tree_view->priv->edited_column)
10596         {
10597           if (GTK_IS_WIDGET (tree_view->priv->edited_column->editable_widget))
10598             {
10599               GList *list;
10600               GtkWidget *widget;
10601               GtkTreeViewChild *child = NULL;
10602
10603               widget = GTK_WIDGET (tree_view->priv->edited_column->editable_widget);
10604               adjust_allocation (widget, 0, dy);
10605
10606               for (list = tree_view->priv->children; list; list = list->next)
10607                 {
10608                   child = (GtkTreeViewChild *)list->data;
10609                   if (child->widget == widget)
10610                     {
10611                       child->y += dy;
10612                       break;
10613                     }
10614                 }
10615             }
10616         }
10617       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
10618
10619       if (tree_view->priv->dy != (int) tree_view->priv->vadjustment->value)
10620         {
10621           /* update our dy and top_row */
10622           tree_view->priv->dy = (int) tree_view->priv->vadjustment->value;
10623
10624           if (!tree_view->priv->in_top_row_to_dy)
10625             gtk_tree_view_dy_to_top_row (tree_view);
10626         }
10627     }
10628 }
10629
10630 \f
10631
10632 /* Public methods
10633  */
10634
10635 /**
10636  * gtk_tree_view_new:
10637  *
10638  * Creates a new #GtkTreeView widget.
10639  *
10640  * Return value: A newly created #GtkTreeView widget.
10641  **/
10642 GtkWidget *
10643 gtk_tree_view_new (void)
10644 {
10645   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
10646 }
10647
10648 /**
10649  * gtk_tree_view_new_with_model:
10650  * @model: the model.
10651  *
10652  * Creates a new #GtkTreeView widget with the model initialized to @model.
10653  *
10654  * Return value: A newly created #GtkTreeView widget.
10655  **/
10656 GtkWidget *
10657 gtk_tree_view_new_with_model (GtkTreeModel *model)
10658 {
10659   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
10660 }
10661
10662 /* Public Accessors
10663  */
10664
10665 /**
10666  * gtk_tree_view_get_model:
10667  * @tree_view: a #GtkTreeView
10668  *
10669  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
10670  * model is unset.
10671  *
10672  * Return value: A #GtkTreeModel, or %NULL if none is currently being used.
10673  **/
10674 GtkTreeModel *
10675 gtk_tree_view_get_model (GtkTreeView *tree_view)
10676 {
10677   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10678
10679   return tree_view->priv->model;
10680 }
10681
10682 /**
10683  * gtk_tree_view_set_model:
10684  * @tree_view: A #GtkTreeNode.
10685  * @model: The model.
10686  *
10687  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
10688  * set, it will remove it before setting the new model.  If @model is %NULL,
10689  * then it will unset the old model.
10690  **/
10691 void
10692 gtk_tree_view_set_model (GtkTreeView  *tree_view,
10693                          GtkTreeModel *model)
10694 {
10695   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10696
10697   if (model != NULL)
10698     g_return_if_fail (GTK_IS_TREE_MODEL (model));
10699
10700   if (model == tree_view->priv->model)
10701     return;
10702
10703   if (tree_view->priv->scroll_to_path)
10704     {
10705       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
10706       tree_view->priv->scroll_to_path = NULL;
10707     }
10708
10709   if (tree_view->priv->model)
10710     {
10711       GList *tmplist = tree_view->priv->columns;
10712
10713       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
10714       gtk_tree_view_stop_editing (tree_view, TRUE);
10715
10716       remove_expand_collapse_timeout (tree_view);
10717
10718       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10719                                             gtk_tree_view_row_changed,
10720                                             tree_view);
10721       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10722                                             gtk_tree_view_row_inserted,
10723                                             tree_view);
10724       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10725                                             gtk_tree_view_row_has_child_toggled,
10726                                             tree_view);
10727       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10728                                             gtk_tree_view_row_deleted,
10729                                             tree_view);
10730       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10731                                             gtk_tree_view_rows_reordered,
10732                                             tree_view);
10733
10734       for (; tmplist; tmplist = tmplist->next)
10735         _gtk_tree_view_column_unset_model (tmplist->data,
10736                                            tree_view->priv->model);
10737
10738       if (tree_view->priv->tree)
10739         gtk_tree_view_free_rbtree (tree_view);
10740
10741       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
10742       tree_view->priv->drag_dest_row = NULL;
10743       gtk_tree_row_reference_free (tree_view->priv->cursor);
10744       tree_view->priv->cursor = NULL;
10745       gtk_tree_row_reference_free (tree_view->priv->anchor);
10746       tree_view->priv->anchor = NULL;
10747       gtk_tree_row_reference_free (tree_view->priv->top_row);
10748       tree_view->priv->top_row = NULL;
10749       gtk_tree_row_reference_free (tree_view->priv->last_button_press);
10750       tree_view->priv->last_button_press = NULL;
10751       gtk_tree_row_reference_free (tree_view->priv->last_button_press_2);
10752       tree_view->priv->last_button_press_2 = NULL;
10753       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
10754       tree_view->priv->scroll_to_path = NULL;
10755
10756       tree_view->priv->scroll_to_column = NULL;
10757
10758       g_object_unref (tree_view->priv->model);
10759
10760       tree_view->priv->search_column = -1;
10761       tree_view->priv->fixed_height_check = 0;
10762       tree_view->priv->fixed_height = -1;
10763       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
10764     }
10765
10766   tree_view->priv->model = model;
10767
10768   if (tree_view->priv->model)
10769     {
10770       gint i;
10771       GtkTreePath *path;
10772       GtkTreeIter iter;
10773       GtkTreeModelFlags flags;
10774
10775       if (tree_view->priv->search_column == -1)
10776         {
10777           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
10778             {
10779               GType type = gtk_tree_model_get_column_type (model, i);
10780
10781               if (g_value_type_transformable (type, G_TYPE_STRING))
10782                 {
10783                   tree_view->priv->search_column = i;
10784                   break;
10785                 }
10786             }
10787         }
10788
10789       g_object_ref (tree_view->priv->model);
10790       g_signal_connect (tree_view->priv->model,
10791                         "row-changed",
10792                         G_CALLBACK (gtk_tree_view_row_changed),
10793                         tree_view);
10794       g_signal_connect (tree_view->priv->model,
10795                         "row-inserted",
10796                         G_CALLBACK (gtk_tree_view_row_inserted),
10797                         tree_view);
10798       g_signal_connect (tree_view->priv->model,
10799                         "row-has-child-toggled",
10800                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
10801                         tree_view);
10802       g_signal_connect (tree_view->priv->model,
10803                         "row-deleted",
10804                         G_CALLBACK (gtk_tree_view_row_deleted),
10805                         tree_view);
10806       g_signal_connect (tree_view->priv->model,
10807                         "rows-reordered",
10808                         G_CALLBACK (gtk_tree_view_rows_reordered),
10809                         tree_view);
10810
10811       flags = gtk_tree_model_get_flags (tree_view->priv->model);
10812       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
10813         GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
10814       else
10815         GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
10816
10817       path = gtk_tree_path_new_first ();
10818       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
10819         {
10820           tree_view->priv->tree = _gtk_rbtree_new ();
10821           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
10822         }
10823       gtk_tree_path_free (path);
10824
10825       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
10826       install_presize_handler (tree_view);
10827     }
10828
10829   g_object_notify (G_OBJECT (tree_view), "model");
10830
10831   if (tree_view->priv->selection)
10832   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
10833
10834   if (GTK_WIDGET_REALIZED (tree_view))
10835     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
10836 }
10837
10838 /**
10839  * gtk_tree_view_get_selection:
10840  * @tree_view: A #GtkTreeView.
10841  *
10842  * Gets the #GtkTreeSelection associated with @tree_view.
10843  *
10844  * Return value: A #GtkTreeSelection object.
10845  **/
10846 GtkTreeSelection *
10847 gtk_tree_view_get_selection (GtkTreeView *tree_view)
10848 {
10849   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10850
10851   return tree_view->priv->selection;
10852 }
10853
10854 /**
10855  * gtk_tree_view_get_hadjustment:
10856  * @tree_view: A #GtkTreeView
10857  *
10858  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
10859  *
10860  * Return value: A #GtkAdjustment object, or %NULL if none is currently being
10861  * used.
10862  **/
10863 GtkAdjustment *
10864 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
10865 {
10866   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10867
10868   if (tree_view->priv->hadjustment == NULL)
10869     gtk_tree_view_set_hadjustment (tree_view, NULL);
10870
10871   return tree_view->priv->hadjustment;
10872 }
10873
10874 /**
10875  * gtk_tree_view_set_hadjustment:
10876  * @tree_view: A #GtkTreeView
10877  * @adjustment: The #GtkAdjustment to set, or %NULL
10878  *
10879  * Sets the #GtkAdjustment for the current horizontal aspect.
10880  **/
10881 void
10882 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
10883                                GtkAdjustment *adjustment)
10884 {
10885   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10886
10887   gtk_tree_view_set_adjustments (tree_view,
10888                                  adjustment,
10889                                  tree_view->priv->vadjustment);
10890
10891   g_object_notify (G_OBJECT (tree_view), "hadjustment");
10892 }
10893
10894 /**
10895  * gtk_tree_view_get_vadjustment:
10896  * @tree_view: A #GtkTreeView
10897  *
10898  * Gets the #GtkAdjustment currently being used for the vertical aspect.
10899  *
10900  * Return value: A #GtkAdjustment object, or %NULL if none is currently being
10901  * used.
10902  **/
10903 GtkAdjustment *
10904 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
10905 {
10906   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10907
10908   if (tree_view->priv->vadjustment == NULL)
10909     gtk_tree_view_set_vadjustment (tree_view, NULL);
10910
10911   return tree_view->priv->vadjustment;
10912 }
10913
10914 /**
10915  * gtk_tree_view_set_vadjustment:
10916  * @tree_view: A #GtkTreeView
10917  * @adjustment: The #GtkAdjustment to set, or %NULL
10918  *
10919  * Sets the #GtkAdjustment for the current vertical aspect.
10920  **/
10921 void
10922 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
10923                                GtkAdjustment *adjustment)
10924 {
10925   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10926
10927   gtk_tree_view_set_adjustments (tree_view,
10928                                  tree_view->priv->hadjustment,
10929                                  adjustment);
10930
10931   g_object_notify (G_OBJECT (tree_view), "vadjustment");
10932 }
10933
10934 /* Column and header operations */
10935
10936 /**
10937  * gtk_tree_view_get_headers_visible:
10938  * @tree_view: A #GtkTreeView.
10939  *
10940  * Returns %TRUE if the headers on the @tree_view are visible.
10941  *
10942  * Return value: Whether the headers are visible or not.
10943  **/
10944 gboolean
10945 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
10946 {
10947   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
10948
10949   return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
10950 }
10951
10952 /**
10953  * gtk_tree_view_set_headers_visible:
10954  * @tree_view: A #GtkTreeView.
10955  * @headers_visible: %TRUE if the headers are visible
10956  *
10957  * Sets the visibility state of the headers.
10958  **/
10959 void
10960 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
10961                                    gboolean     headers_visible)
10962 {
10963   gint x, y;
10964   GList *list;
10965   GtkTreeViewColumn *column;
10966
10967   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10968
10969   headers_visible = !! headers_visible;
10970
10971   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE) == headers_visible)
10972     return;
10973
10974   if (headers_visible)
10975     GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
10976   else
10977     GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
10978
10979   if (GTK_WIDGET_REALIZED (tree_view))
10980     {
10981       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
10982       if (headers_visible)
10983         {
10984           gdk_window_move_resize (tree_view->priv->bin_window, x, y  + TREE_VIEW_HEADER_HEIGHT (tree_view), tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.height -  + TREE_VIEW_HEADER_HEIGHT (tree_view));
10985
10986           if (GTK_WIDGET_MAPPED (tree_view))
10987             gtk_tree_view_map_buttons (tree_view);
10988         }
10989       else
10990         {
10991           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
10992
10993           for (list = tree_view->priv->columns; list; list = list->next)
10994             {
10995               column = list->data;
10996               gtk_widget_unmap (column->button);
10997             }
10998           gdk_window_hide (tree_view->priv->header_window);
10999         }
11000     }
11001
11002   tree_view->priv->vadjustment->page_size = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
11003   tree_view->priv->vadjustment->page_increment = (GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2;
11004   tree_view->priv->vadjustment->lower = 0;
11005   tree_view->priv->vadjustment->upper = tree_view->priv->height;
11006   gtk_adjustment_changed (tree_view->priv->vadjustment);
11007
11008   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11009
11010   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11011 }
11012
11013 /**
11014  * gtk_tree_view_columns_autosize:
11015  * @tree_view: A #GtkTreeView.
11016  *
11017  * Resizes all columns to their optimal width. Only works after the
11018  * treeview has been realized.
11019  **/
11020 void
11021 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11022 {
11023   gboolean dirty = FALSE;
11024   GList *list;
11025   GtkTreeViewColumn *column;
11026
11027   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11028
11029   for (list = tree_view->priv->columns; list; list = list->next)
11030     {
11031       column = list->data;
11032       if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11033         continue;
11034       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11035       dirty = TRUE;
11036     }
11037
11038   if (dirty)
11039     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11040 }
11041
11042 /**
11043  * gtk_tree_view_set_headers_clickable:
11044  * @tree_view: A #GtkTreeView.
11045  * @setting: %TRUE if the columns are clickable.
11046  *
11047  * Allow the column title buttons to be clicked.
11048  **/
11049 void
11050 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11051                                      gboolean   setting)
11052 {
11053   GList *list;
11054
11055   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11056
11057   for (list = tree_view->priv->columns; list; list = list->next)
11058     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11059
11060   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11061 }
11062
11063
11064 /**
11065  * gtk_tree_view_get_headers_clickable:
11066  * @tree_view: A #GtkTreeView.
11067  *
11068  * Returns whether all header columns are clickable.
11069  *
11070  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11071  *
11072  * Since: 2.10
11073  **/
11074 gboolean
11075 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11076 {
11077   GList *list;
11078
11079   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11080
11081   for (list = tree_view->priv->columns; list; list = list->next)
11082     if (!GTK_TREE_VIEW_COLUMN (list->data)->clickable)
11083       return FALSE;
11084
11085   return TRUE;
11086 }
11087
11088 /**
11089  * gtk_tree_view_set_rules_hint
11090  * @tree_view: a #GtkTreeView
11091  * @setting: %TRUE if the tree requires reading across rows
11092  *
11093  * This function tells GTK+ that the user interface for your
11094  * application requires users to read across tree rows and associate
11095  * cells with one another. By default, GTK+ will then render the tree
11096  * with alternating row colors. Do <emphasis>not</emphasis> use it
11097  * just because you prefer the appearance of the ruled tree; that's a
11098  * question for the theme. Some themes will draw tree rows in
11099  * alternating colors even when rules are turned off, and users who
11100  * prefer that appearance all the time can choose those themes. You
11101  * should call this function only as a <emphasis>semantic</emphasis>
11102  * hint to the theme engine that your tree makes alternating colors
11103  * useful from a functional standpoint (since it has lots of columns,
11104  * generally).
11105  *
11106  **/
11107 void
11108 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11109                               gboolean      setting)
11110 {
11111   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11112
11113   setting = setting != FALSE;
11114
11115   if (tree_view->priv->has_rules != setting)
11116     {
11117       tree_view->priv->has_rules = setting;
11118       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11119     }
11120
11121   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11122 }
11123
11124 /**
11125  * gtk_tree_view_get_rules_hint
11126  * @tree_view: a #GtkTreeView
11127  *
11128  * Gets the setting set by gtk_tree_view_set_rules_hint().
11129  *
11130  * Return value: %TRUE if rules are useful for the user of this tree
11131  **/
11132 gboolean
11133 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11134 {
11135   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11136
11137   return tree_view->priv->has_rules;
11138 }
11139
11140 /* Public Column functions
11141  */
11142
11143 /**
11144  * gtk_tree_view_append_column:
11145  * @tree_view: A #GtkTreeView.
11146  * @column: The #GtkTreeViewColumn to add.
11147  *
11148  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11149  * mode enabled, then @column must have its "sizing" property set to be
11150  * GTK_TREE_VIEW_COLUMN_FIXED.
11151  *
11152  * Return value: The number of columns in @tree_view after appending.
11153  **/
11154 gint
11155 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11156                              GtkTreeViewColumn *column)
11157 {
11158   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11159   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11160   g_return_val_if_fail (column->tree_view == NULL, -1);
11161
11162   return gtk_tree_view_insert_column (tree_view, column, -1);
11163 }
11164
11165
11166 /**
11167  * gtk_tree_view_remove_column:
11168  * @tree_view: A #GtkTreeView.
11169  * @column: The #GtkTreeViewColumn to remove.
11170  *
11171  * Removes @column from @tree_view.
11172  *
11173  * Return value: The number of columns in @tree_view after removing.
11174  **/
11175 gint
11176 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11177                              GtkTreeViewColumn *column)
11178 {
11179   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11180   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11181   g_return_val_if_fail (column->tree_view == GTK_WIDGET (tree_view), -1);
11182
11183   if (tree_view->priv->focus_column == column)
11184     tree_view->priv->focus_column = NULL;
11185
11186   if (tree_view->priv->edited_column == column)
11187     {
11188       gtk_tree_view_stop_editing (tree_view, TRUE);
11189
11190       /* no need to, but just to be sure ... */
11191       tree_view->priv->edited_column = NULL;
11192     }
11193
11194   g_signal_handlers_disconnect_by_func (column,
11195                                         G_CALLBACK (column_sizing_notify),
11196                                         tree_view);
11197
11198   _gtk_tree_view_column_unset_tree_view (column);
11199
11200   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11201   tree_view->priv->n_columns--;
11202
11203   if (GTK_WIDGET_REALIZED (tree_view))
11204     {
11205       GList *list;
11206
11207       _gtk_tree_view_column_unrealize_button (column);
11208       for (list = tree_view->priv->columns; list; list = list->next)
11209         {
11210           GtkTreeViewColumn *tmp_column;
11211
11212           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11213           if (tmp_column->visible)
11214             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
11215         }
11216
11217       if (tree_view->priv->n_columns == 0 &&
11218           gtk_tree_view_get_headers_visible (tree_view))
11219         gdk_window_hide (tree_view->priv->header_window);
11220
11221       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11222     }
11223
11224   g_object_unref (column);
11225   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11226
11227   return tree_view->priv->n_columns;
11228 }
11229
11230 /**
11231  * gtk_tree_view_insert_column:
11232  * @tree_view: A #GtkTreeView.
11233  * @column: The #GtkTreeViewColumn to be inserted.
11234  * @position: The position to insert @column in.
11235  *
11236  * This inserts the @column into the @tree_view at @position.  If @position is
11237  * -1, then the column is inserted at the end. If @tree_view has
11238  * "fixed_height" mode enabled, then @column must have its "sizing" property
11239  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
11240  *
11241  * Return value: The number of columns in @tree_view after insertion.
11242  **/
11243 gint
11244 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
11245                              GtkTreeViewColumn *column,
11246                              gint               position)
11247 {
11248   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11249   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11250   g_return_val_if_fail (column->tree_view == NULL, -1);
11251
11252   if (tree_view->priv->fixed_height_mode)
11253     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
11254                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
11255
11256   g_object_ref_sink (column);
11257
11258   if (tree_view->priv->n_columns == 0 &&
11259       GTK_WIDGET_REALIZED (tree_view) &&
11260       gtk_tree_view_get_headers_visible (tree_view))
11261     {
11262       gdk_window_show (tree_view->priv->header_window);
11263     }
11264
11265   g_signal_connect (column, "notify::sizing",
11266                     G_CALLBACK (column_sizing_notify), tree_view);
11267
11268   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
11269                                             column, position);
11270   tree_view->priv->n_columns++;
11271
11272   _gtk_tree_view_column_set_tree_view (column, tree_view);
11273
11274   if (GTK_WIDGET_REALIZED (tree_view))
11275     {
11276       GList *list;
11277
11278       _gtk_tree_view_column_realize_button (column);
11279
11280       for (list = tree_view->priv->columns; list; list = list->next)
11281         {
11282           column = GTK_TREE_VIEW_COLUMN (list->data);
11283           if (column->visible)
11284             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11285         }
11286       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11287     }
11288
11289   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11290
11291   return tree_view->priv->n_columns;
11292 }
11293
11294 /**
11295  * gtk_tree_view_insert_column_with_attributes:
11296  * @tree_view: A #GtkTreeView
11297  * @position: The position to insert the new column in.
11298  * @title: The title to set the header to.
11299  * @cell: The #GtkCellRenderer.
11300  * @Varargs: A %NULL-terminated list of attributes.
11301  *
11302  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
11303  * @position.  If @position is -1, then the newly created column is inserted at
11304  * the end.  The column is initialized with the attributes given. If @tree_view
11305  * has "fixed_height" mode enabled, then the new column will have its sizing
11306  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
11307  *
11308  * Return value: The number of columns in @tree_view after insertion.
11309  **/
11310 gint
11311 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
11312                                              gint             position,
11313                                              const gchar     *title,
11314                                              GtkCellRenderer *cell,
11315                                              ...)
11316 {
11317   GtkTreeViewColumn *column;
11318   gchar *attribute;
11319   va_list args;
11320   gint column_id;
11321
11322   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11323
11324   column = gtk_tree_view_column_new ();
11325   if (tree_view->priv->fixed_height_mode)
11326     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
11327
11328   gtk_tree_view_column_set_title (column, title);
11329   gtk_tree_view_column_pack_start (column, cell, TRUE);
11330
11331   va_start (args, cell);
11332
11333   attribute = va_arg (args, gchar *);
11334
11335   while (attribute != NULL)
11336     {
11337       column_id = va_arg (args, gint);
11338       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
11339       attribute = va_arg (args, gchar *);
11340     }
11341
11342   va_end (args);
11343
11344   gtk_tree_view_insert_column (tree_view, column, position);
11345
11346   return tree_view->priv->n_columns;
11347 }
11348
11349 /**
11350  * gtk_tree_view_insert_column_with_data_func:
11351  * @tree_view: a #GtkTreeView
11352  * @position: Position to insert, -1 for append
11353  * @title: column title
11354  * @cell: cell renderer for column
11355  * @func: function to set attributes of cell renderer
11356  * @data: data for @func
11357  * @dnotify: destroy notifier for @data
11358  *
11359  * Convenience function that inserts a new column into the #GtkTreeView
11360  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
11361  * attributes (normally using data from the model). See also
11362  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
11363  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
11364  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
11365  *
11366  * Return value: number of columns in the tree view post-insert
11367  **/
11368 gint
11369 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
11370                                              gint                       position,
11371                                              const gchar               *title,
11372                                              GtkCellRenderer           *cell,
11373                                              GtkTreeCellDataFunc        func,
11374                                              gpointer                   data,
11375                                              GDestroyNotify             dnotify)
11376 {
11377   GtkTreeViewColumn *column;
11378
11379   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11380
11381   column = gtk_tree_view_column_new ();
11382   if (tree_view->priv->fixed_height_mode)
11383     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
11384
11385   gtk_tree_view_column_set_title (column, title);
11386   gtk_tree_view_column_pack_start (column, cell, TRUE);
11387   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
11388
11389   gtk_tree_view_insert_column (tree_view, column, position);
11390
11391   return tree_view->priv->n_columns;
11392 }
11393
11394 /**
11395  * gtk_tree_view_get_column:
11396  * @tree_view: A #GtkTreeView.
11397  * @n: The position of the column, counting from 0.
11398  *
11399  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
11400  *
11401  * Return value: The #GtkTreeViewColumn, or %NULL if the position is outside the
11402  * range of columns.
11403  **/
11404 GtkTreeViewColumn *
11405 gtk_tree_view_get_column (GtkTreeView *tree_view,
11406                           gint         n)
11407 {
11408   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11409
11410   if (n < 0 || n >= tree_view->priv->n_columns)
11411     return NULL;
11412
11413   if (tree_view->priv->columns == NULL)
11414     return NULL;
11415
11416   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
11417 }
11418
11419 /**
11420  * gtk_tree_view_get_columns:
11421  * @tree_view: A #GtkTreeView
11422  *
11423  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
11424  * The returned list must be freed with g_list_free ().
11425  *
11426  * Return value: A list of #GtkTreeViewColumn s
11427  **/
11428 GList *
11429 gtk_tree_view_get_columns (GtkTreeView *tree_view)
11430 {
11431   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11432
11433   return g_list_copy (tree_view->priv->columns);
11434 }
11435
11436 /**
11437  * gtk_tree_view_move_column_after:
11438  * @tree_view: A #GtkTreeView
11439  * @column: The #GtkTreeViewColumn to be moved.
11440  * @base_column: The #GtkTreeViewColumn to be moved relative to, or %NULL.
11441  *
11442  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
11443  * @column is placed in the first position.
11444  **/
11445 void
11446 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
11447                                  GtkTreeViewColumn *column,
11448                                  GtkTreeViewColumn *base_column)
11449 {
11450   GList *column_list_el, *base_el = NULL;
11451
11452   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11453
11454   column_list_el = g_list_find (tree_view->priv->columns, column);
11455   g_return_if_fail (column_list_el != NULL);
11456
11457   if (base_column)
11458     {
11459       base_el = g_list_find (tree_view->priv->columns, base_column);
11460       g_return_if_fail (base_el != NULL);
11461     }
11462
11463   if (column_list_el->prev == base_el)
11464     return;
11465
11466   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
11467   if (base_el == NULL)
11468     {
11469       column_list_el->prev = NULL;
11470       column_list_el->next = tree_view->priv->columns;
11471       if (column_list_el->next)
11472         column_list_el->next->prev = column_list_el;
11473       tree_view->priv->columns = column_list_el;
11474     }
11475   else
11476     {
11477       column_list_el->prev = base_el;
11478       column_list_el->next = base_el->next;
11479       if (column_list_el->next)
11480         column_list_el->next->prev = column_list_el;
11481       base_el->next = column_list_el;
11482     }
11483
11484   if (GTK_WIDGET_REALIZED (tree_view))
11485     {
11486       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11487       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
11488     }
11489
11490   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11491 }
11492
11493 /**
11494  * gtk_tree_view_set_expander_column:
11495  * @tree_view: A #GtkTreeView
11496  * @column: %NULL, or the column to draw the expander arrow at.
11497  *
11498  * Sets the column to draw the expander arrow at. It must be in @tree_view.
11499  * If @column is %NULL, then the expander arrow is always at the first
11500  * visible column.
11501  *
11502  * If you do not want expander arrow to appear in your tree, set the
11503  * expander column to a hidden column.
11504  **/
11505 void
11506 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
11507                                    GtkTreeViewColumn *column)
11508 {
11509   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11510   if (column != NULL)
11511     g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
11512
11513   if (tree_view->priv->expander_column != column)
11514     {
11515       GList *list;
11516
11517       if (column)
11518         {
11519           /* Confirm that column is in tree_view */
11520           for (list = tree_view->priv->columns; list; list = list->next)
11521             if (list->data == column)
11522               break;
11523           g_return_if_fail (list != NULL);
11524         }
11525
11526       tree_view->priv->expander_column = column;
11527       g_object_notify (G_OBJECT (tree_view), "expander-column");
11528     }
11529 }
11530
11531 /**
11532  * gtk_tree_view_get_expander_column:
11533  * @tree_view: A #GtkTreeView
11534  *
11535  * Returns the column that is the current expander column.  This
11536  * column has the expander arrow drawn next to it.
11537  *
11538  * Return value: The expander column.
11539  **/
11540 GtkTreeViewColumn *
11541 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
11542 {
11543   GList *list;
11544
11545   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11546
11547   for (list = tree_view->priv->columns; list; list = list->next)
11548     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
11549       return (GtkTreeViewColumn *) list->data;
11550   return NULL;
11551 }
11552
11553
11554 /**
11555  * gtk_tree_view_set_column_drag_function:
11556  * @tree_view: A #GtkTreeView.
11557  * @func: A function to determine which columns are reorderable, or %NULL.
11558  * @user_data: User data to be passed to @func, or %NULL
11559  * @destroy: Destroy notifier for @user_data, or %NULL
11560  *
11561  * Sets a user function for determining where a column may be dropped when
11562  * dragged.  This function is called on every column pair in turn at the
11563  * beginning of a column drag to determine where a drop can take place.  The
11564  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
11565  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
11566  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
11567  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
11568  * @tree_view reverts to the default behavior of allowing all columns to be
11569  * dropped everywhere.
11570  **/
11571 void
11572 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
11573                                         GtkTreeViewColumnDropFunc  func,
11574                                         gpointer                   user_data,
11575                                         GDestroyNotify             destroy)
11576 {
11577   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11578
11579   if (tree_view->priv->column_drop_func_data_destroy)
11580     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
11581
11582   tree_view->priv->column_drop_func = func;
11583   tree_view->priv->column_drop_func_data = user_data;
11584   tree_view->priv->column_drop_func_data_destroy = destroy;
11585 }
11586
11587 /**
11588  * gtk_tree_view_scroll_to_point:
11589  * @tree_view: a #GtkTreeView
11590  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
11591  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
11592  *
11593  * Scrolls the tree view such that the top-left corner of the visible
11594  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
11595  * in tree coordinates.  The @tree_view must be realized before
11596  * this function is called.  If it isn't, you probably want to be
11597  * using gtk_tree_view_scroll_to_cell().
11598  *
11599  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
11600  **/
11601 void
11602 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
11603                                gint         tree_x,
11604                                gint         tree_y)
11605 {
11606   GtkAdjustment *hadj;
11607   GtkAdjustment *vadj;
11608
11609   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11610   g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
11611
11612   hadj = tree_view->priv->hadjustment;
11613   vadj = tree_view->priv->vadjustment;
11614
11615   if (tree_x != -1)
11616     gtk_adjustment_set_value (hadj, tree_x);
11617   if (tree_y != -1)
11618     gtk_adjustment_set_value (vadj, tree_y);
11619 }
11620
11621 /**
11622  * gtk_tree_view_scroll_to_cell:
11623  * @tree_view: A #GtkTreeView.
11624  * @path: The path of the row to move to, or %NULL.
11625  * @column: The #GtkTreeViewColumn to move horizontally to, or %NULL.
11626  * @use_align: whether to use alignment arguments, or %FALSE.
11627  * @row_align: The vertical alignment of the row specified by @path.
11628  * @col_align: The horizontal alignment of the column specified by @column.
11629  *
11630  * Moves the alignments of @tree_view to the position specified by @column and
11631  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
11632  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
11633  * or @path need to be non-%NULL.  @row_align determines where the row is
11634  * placed, and @col_align determines where @column is placed.  Both are expected
11635  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
11636  * right/bottom alignment, 0.5 means center.
11637  *
11638  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
11639  * tree does the minimum amount of work to scroll the cell onto the screen.
11640  * This means that the cell will be scrolled to the edge closest to its current
11641  * position.  If the cell is currently visible on the screen, nothing is done.
11642  *
11643  * This function only works if the model is set, and @path is a valid row on the
11644  * model.  If the model changes before the @tree_view is realized, the centered
11645  * path will be modified to reflect this change.
11646  **/
11647 void
11648 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
11649                               GtkTreePath       *path,
11650                               GtkTreeViewColumn *column,
11651                               gboolean           use_align,
11652                               gfloat             row_align,
11653                               gfloat             col_align)
11654 {
11655   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11656   g_return_if_fail (tree_view->priv->model != NULL);
11657   g_return_if_fail (tree_view->priv->tree != NULL);
11658   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
11659   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
11660   g_return_if_fail (path != NULL || column != NULL);
11661
11662 #if 0
11663   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
11664            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
11665 #endif
11666   row_align = CLAMP (row_align, 0.0, 1.0);
11667   col_align = CLAMP (col_align, 0.0, 1.0);
11668
11669
11670   /* Note: Despite the benefits that come from having one code path for the
11671    * scrolling code, we short-circuit validate_visible_area's immplementation as
11672    * it is much slower than just going to the point.
11673    */
11674   if (! GTK_WIDGET_VISIBLE (tree_view) ||
11675       ! GTK_WIDGET_REALIZED (tree_view) ||
11676       GTK_WIDGET_ALLOC_NEEDED (tree_view) ||
11677       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
11678     {
11679       if (tree_view->priv->scroll_to_path)
11680         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11681
11682       tree_view->priv->scroll_to_path = NULL;
11683       tree_view->priv->scroll_to_column = NULL;
11684
11685       if (path)
11686         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
11687       if (column)
11688         tree_view->priv->scroll_to_column = column;
11689       tree_view->priv->scroll_to_use_align = use_align;
11690       tree_view->priv->scroll_to_row_align = row_align;
11691       tree_view->priv->scroll_to_col_align = col_align;
11692
11693       install_presize_handler (tree_view);
11694     }
11695   else
11696     {
11697       GdkRectangle cell_rect;
11698       GdkRectangle vis_rect;
11699       gint dest_x, dest_y;
11700
11701       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
11702       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
11703
11704       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
11705
11706       dest_x = vis_rect.x;
11707       dest_y = vis_rect.y;
11708
11709       if (column)
11710         {
11711           if (use_align)
11712             {
11713               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
11714             }
11715           else
11716             {
11717               if (cell_rect.x < vis_rect.x)
11718                 dest_x = cell_rect.x;
11719               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
11720                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
11721             }
11722         }
11723
11724       if (path)
11725         {
11726           if (use_align)
11727             {
11728               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
11729               dest_y = MAX (dest_y, 0);
11730             }
11731           else
11732             {
11733               if (cell_rect.y < vis_rect.y)
11734                 dest_y = cell_rect.y;
11735               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
11736                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
11737             }
11738         }
11739
11740       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
11741     }
11742 }
11743
11744 /**
11745  * gtk_tree_view_row_activated:
11746  * @tree_view: A #GtkTreeView
11747  * @path: The #GtkTreePath to be activated.
11748  * @column: The #GtkTreeViewColumn to be activated.
11749  *
11750  * Activates the cell determined by @path and @column.
11751  **/
11752 void
11753 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
11754                              GtkTreePath       *path,
11755                              GtkTreeViewColumn *column)
11756 {
11757   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11758
11759   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
11760 }
11761
11762
11763 static void
11764 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
11765                                           GtkRBNode *node,
11766                                           gpointer   data)
11767 {
11768   GtkTreeView *tree_view = data;
11769
11770   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
11771       node->children)
11772     {
11773       GtkTreePath *path;
11774       GtkTreeIter iter;
11775
11776       path = _gtk_tree_view_find_path (tree_view, tree, node);
11777       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
11778
11779       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
11780
11781       gtk_tree_path_free (path);
11782     }
11783
11784   if (node->children)
11785     _gtk_rbtree_traverse (node->children,
11786                           node->children->root,
11787                           G_PRE_ORDER,
11788                           gtk_tree_view_expand_all_emission_helper,
11789                           tree_view);
11790 }
11791
11792 /**
11793  * gtk_tree_view_expand_all:
11794  * @tree_view: A #GtkTreeView.
11795  *
11796  * Recursively expands all nodes in the @tree_view.
11797  **/
11798 void
11799 gtk_tree_view_expand_all (GtkTreeView *tree_view)
11800 {
11801   GtkTreePath *path;
11802   GtkRBTree *tree;
11803   GtkRBNode *node;
11804
11805   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11806
11807   if (tree_view->priv->tree == NULL)
11808     return;
11809
11810   path = gtk_tree_path_new_first ();
11811   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
11812
11813   while (node)
11814     {
11815       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
11816       node = _gtk_rbtree_next (tree, node);
11817       gtk_tree_path_next (path);
11818   }
11819
11820   gtk_tree_path_free (path);
11821 }
11822
11823 /* Timeout to animate the expander during expands and collapses */
11824 static gboolean
11825 expand_collapse_timeout (gpointer data)
11826 {
11827   return do_expand_collapse (data);
11828 }
11829
11830 static void
11831 add_expand_collapse_timeout (GtkTreeView *tree_view,
11832                              GtkRBTree   *tree,
11833                              GtkRBNode   *node,
11834                              gboolean     expand)
11835 {
11836   if (tree_view->priv->expand_collapse_timeout != 0)
11837     return;
11838
11839   tree_view->priv->expand_collapse_timeout =
11840       gdk_threads_add_timeout (50, expand_collapse_timeout, tree_view);
11841   tree_view->priv->expanded_collapsed_tree = tree;
11842   tree_view->priv->expanded_collapsed_node = node;
11843
11844   if (expand)
11845     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11846   else
11847     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11848 }
11849
11850 static void
11851 remove_expand_collapse_timeout (GtkTreeView *tree_view)
11852 {
11853   if (tree_view->priv->expand_collapse_timeout)
11854     {
11855       g_source_remove (tree_view->priv->expand_collapse_timeout);
11856       tree_view->priv->expand_collapse_timeout = 0;
11857     }
11858
11859   if (tree_view->priv->expanded_collapsed_node != NULL)
11860     {
11861       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_EXPANDED);
11862       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11863
11864       tree_view->priv->expanded_collapsed_node = NULL;
11865     }
11866 }
11867
11868 static void
11869 cancel_arrow_animation (GtkTreeView *tree_view)
11870 {
11871   if (tree_view->priv->expand_collapse_timeout)
11872     {
11873       while (do_expand_collapse (tree_view));
11874
11875       remove_expand_collapse_timeout (tree_view);
11876     }
11877 }
11878
11879 static gboolean
11880 do_expand_collapse (GtkTreeView *tree_view)
11881 {
11882   GtkRBNode *node;
11883   GtkRBTree *tree;
11884   gboolean expanding;
11885   gboolean redraw;
11886
11887   redraw = FALSE;
11888   expanding = TRUE;
11889
11890   node = tree_view->priv->expanded_collapsed_node;
11891   tree = tree_view->priv->expanded_collapsed_tree;
11892
11893   if (node->children == NULL)
11894     expanding = FALSE;
11895
11896   if (expanding)
11897     {
11898       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
11899         {
11900           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11901           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11902
11903           redraw = TRUE;
11904
11905         }
11906       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
11907         {
11908           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11909
11910           redraw = TRUE;
11911         }
11912     }
11913   else
11914     {
11915       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
11916         {
11917           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11918           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11919
11920           redraw = TRUE;
11921         }
11922       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
11923         {
11924           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11925
11926           redraw = TRUE;
11927
11928         }
11929     }
11930
11931   if (redraw)
11932     {
11933       gtk_tree_view_queue_draw_arrow (tree_view, tree, node, NULL);
11934
11935       return TRUE;
11936     }
11937
11938   return FALSE;
11939 }
11940
11941 /**
11942  * gtk_tree_view_collapse_all:
11943  * @tree_view: A #GtkTreeView.
11944  *
11945  * Recursively collapses all visible, expanded nodes in @tree_view.
11946  **/
11947 void
11948 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
11949 {
11950   GtkRBTree *tree;
11951   GtkRBNode *node;
11952   GtkTreePath *path;
11953   gint *indices;
11954
11955   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11956
11957   if (tree_view->priv->tree == NULL)
11958     return;
11959
11960   path = gtk_tree_path_new ();
11961   gtk_tree_path_down (path);
11962   indices = gtk_tree_path_get_indices (path);
11963
11964   tree = tree_view->priv->tree;
11965   node = tree->root;
11966   while (node && node->left != tree->nil)
11967     node = node->left;
11968
11969   while (node)
11970     {
11971       if (node->children)
11972         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
11973       indices[0]++;
11974       node = _gtk_rbtree_next (tree, node);
11975     }
11976
11977   gtk_tree_path_free (path);
11978 }
11979
11980 /**
11981  * gtk_tree_view_expand_to_path:
11982  * @tree_view: A #GtkTreeView.
11983  * @path: path to a row.
11984  *
11985  * Expands the row at @path. This will also expand all parent rows of
11986  * @path as necessary.
11987  *
11988  * Since: 2.2
11989  **/
11990 void
11991 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
11992                               GtkTreePath *path)
11993 {
11994   gint i, depth;
11995   gint *indices;
11996   GtkTreePath *tmp;
11997
11998   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11999   g_return_if_fail (path != NULL);
12000
12001   depth = gtk_tree_path_get_depth (path);
12002   indices = gtk_tree_path_get_indices (path);
12003
12004   tmp = gtk_tree_path_new ();
12005   g_return_if_fail (tmp != NULL);
12006
12007   for (i = 0; i < depth; i++)
12008     {
12009       gtk_tree_path_append_index (tmp, indices[i]);
12010       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12011     }
12012
12013   gtk_tree_path_free (tmp);
12014 }
12015
12016 /* FIXME the bool return values for expand_row and collapse_row are
12017  * not analagous; they should be TRUE if the row had children and
12018  * was not already in the requested state.
12019  */
12020
12021
12022 static gboolean
12023 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12024                                GtkTreePath *path,
12025                                GtkRBTree   *tree,
12026                                GtkRBNode   *node,
12027                                gboolean     open_all,
12028                                gboolean     animate)
12029 {
12030   GtkTreeIter iter;
12031   GtkTreeIter temp;
12032   gboolean expand;
12033
12034   if (animate)
12035     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12036                   "gtk-enable-animations", &animate,
12037                   NULL);
12038
12039   remove_auto_expand_timeout (tree_view);
12040
12041   if (node->children && !open_all)
12042     return FALSE;
12043
12044   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12045     return FALSE;
12046
12047   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12048   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12049     return FALSE;
12050
12051
12052    if (node->children && open_all)
12053     {
12054       gboolean retval = FALSE;
12055       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12056
12057       gtk_tree_path_append_index (tmp_path, 0);
12058       tree = node->children;
12059       node = tree->root;
12060       while (node->left != tree->nil)
12061         node = node->left;
12062       /* try to expand the children */
12063       do
12064         {
12065          gboolean t;
12066          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12067                                             TRUE, animate);
12068          if (t)
12069            retval = TRUE;
12070
12071          gtk_tree_path_next (tmp_path);
12072          node = _gtk_rbtree_next (tree, node);
12073        }
12074       while (node != NULL);
12075
12076       gtk_tree_path_free (tmp_path);
12077
12078       return retval;
12079     }
12080
12081   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12082
12083   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12084     return FALSE;
12085
12086   if (expand)
12087     return FALSE;
12088
12089   node->children = _gtk_rbtree_new ();
12090   node->children->parent_tree = tree;
12091   node->children->parent_node = node;
12092
12093   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12094
12095   gtk_tree_view_build_tree (tree_view,
12096                             node->children,
12097                             &temp,
12098                             gtk_tree_path_get_depth (path) + 1,
12099                             open_all);
12100
12101   remove_expand_collapse_timeout (tree_view);
12102
12103   if (animate)
12104     add_expand_collapse_timeout (tree_view, tree, node, TRUE);
12105
12106   install_presize_handler (tree_view);
12107
12108   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12109   if (open_all && node->children)
12110     {
12111       _gtk_rbtree_traverse (node->children,
12112                             node->children->root,
12113                             G_PRE_ORDER,
12114                             gtk_tree_view_expand_all_emission_helper,
12115                             tree_view);
12116     }
12117   return TRUE;
12118 }
12119
12120
12121 /**
12122  * gtk_tree_view_expand_row:
12123  * @tree_view: a #GtkTreeView
12124  * @path: path to a row
12125  * @open_all: whether to recursively expand, or just expand immediate children
12126  *
12127  * Opens the row so its children are visible.
12128  *
12129  * Return value: %TRUE if the row existed and had children
12130  **/
12131 gboolean
12132 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12133                           GtkTreePath *path,
12134                           gboolean     open_all)
12135 {
12136   GtkRBTree *tree;
12137   GtkRBNode *node;
12138
12139   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12140   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12141   g_return_val_if_fail (path != NULL, FALSE);
12142
12143   if (_gtk_tree_view_find_node (tree_view,
12144                                 path,
12145                                 &tree,
12146                                 &node))
12147     return FALSE;
12148
12149   if (tree != NULL)
12150     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12151   else
12152     return FALSE;
12153 }
12154
12155 static gboolean
12156 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12157                                  GtkTreePath *path,
12158                                  GtkRBTree   *tree,
12159                                  GtkRBNode   *node,
12160                                  gboolean     animate)
12161 {
12162   GtkTreeIter iter;
12163   GtkTreeIter children;
12164   gboolean collapse;
12165   gint x, y;
12166   GList *list;
12167   GdkWindow *child, *parent;
12168
12169   if (animate)
12170     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12171                   "gtk-enable-animations", &animate,
12172                   NULL);
12173
12174   remove_auto_expand_timeout (tree_view);
12175
12176   if (node->children == NULL)
12177     return FALSE;
12178
12179   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12180
12181   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12182
12183   if (collapse)
12184     return FALSE;
12185
12186   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12187    * a chance to prelight the correct node below */
12188
12189   if (tree_view->priv->prelight_tree)
12190     {
12191       GtkRBTree *parent_tree;
12192       GtkRBNode *parent_node;
12193
12194       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12195       parent_node = tree_view->priv->prelight_tree->parent_node;
12196       while (parent_tree)
12197         {
12198           if (parent_tree == tree && parent_node == node)
12199             {
12200               ensure_unprelighted (tree_view);
12201               break;
12202             }
12203           parent_node = parent_tree->parent_node;
12204           parent_tree = parent_tree->parent_tree;
12205         }
12206     }
12207
12208   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12209
12210   for (list = tree_view->priv->columns; list; list = list->next)
12211     {
12212       GtkTreeViewColumn *column = list->data;
12213
12214       if (column->visible == FALSE)
12215         continue;
12216       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12217         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12218     }
12219
12220   if (tree_view->priv->destroy_count_func)
12221     {
12222       GtkTreePath *child_path;
12223       gint child_count = 0;
12224       child_path = gtk_tree_path_copy (path);
12225       gtk_tree_path_down (child_path);
12226       if (node->children)
12227         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12228       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12229       gtk_tree_path_free (child_path);
12230     }
12231
12232   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12233     {
12234       GtkTreePath *cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12235
12236       if (gtk_tree_path_is_ancestor (path, cursor_path))
12237         {
12238           gtk_tree_row_reference_free (tree_view->priv->cursor);
12239           tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
12240                                                                       tree_view->priv->model,
12241                                                                       path);
12242         }
12243       gtk_tree_path_free (cursor_path);
12244     }
12245
12246   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12247     {
12248       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12249       if (gtk_tree_path_is_ancestor (path, anchor_path))
12250         {
12251           gtk_tree_row_reference_free (tree_view->priv->anchor);
12252           tree_view->priv->anchor = NULL;
12253         }
12254       gtk_tree_path_free (anchor_path);
12255     }
12256
12257   if (gtk_tree_row_reference_valid (tree_view->priv->last_button_press))
12258     {
12259       GtkTreePath *lsc = gtk_tree_row_reference_get_path (tree_view->priv->last_button_press);
12260       if (gtk_tree_path_is_ancestor (path, lsc))
12261         {
12262           gtk_tree_row_reference_free (tree_view->priv->last_button_press);
12263           tree_view->priv->last_button_press = NULL;
12264         }
12265       gtk_tree_path_free (lsc);
12266     }
12267
12268   if (gtk_tree_row_reference_valid (tree_view->priv->last_button_press_2))
12269     {
12270       GtkTreePath *lsc = gtk_tree_row_reference_get_path (tree_view->priv->last_button_press_2);
12271       if (gtk_tree_path_is_ancestor (path, lsc))
12272         {
12273           gtk_tree_row_reference_free (tree_view->priv->last_button_press_2);
12274           tree_view->priv->last_button_press_2 = NULL;
12275         }
12276       gtk_tree_path_free (lsc);
12277     }
12278
12279   remove_expand_collapse_timeout (tree_view);
12280
12281   if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children))
12282     {
12283       _gtk_rbtree_remove (node->children);
12284       g_signal_emit_by_name (tree_view->priv->selection, "changed");
12285     }
12286   else
12287     _gtk_rbtree_remove (node->children);
12288
12289   if (animate)
12290     add_expand_collapse_timeout (tree_view, tree, node, FALSE);
12291
12292   if (GTK_WIDGET_MAPPED (tree_view))
12293     {
12294       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12295     }
12296
12297   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12298
12299   if (GTK_WIDGET_MAPPED (tree_view))
12300     {
12301       /* now that we've collapsed all rows, we want to try to set the prelight
12302        * again. To do this, we fake a motion event and send it to ourselves. */
12303
12304       child = tree_view->priv->bin_window;
12305       parent = gdk_window_get_parent (child);
12306
12307       if (gdk_window_get_pointer (parent, &x, &y, NULL) == child)
12308         {
12309           GdkEventMotion event;
12310           gint child_x, child_y;
12311
12312           gdk_window_get_position (child, &child_x, &child_y);
12313
12314           event.window = tree_view->priv->bin_window;
12315           event.x = x - child_x;
12316           event.y = y - child_y;
12317
12318           /* despite the fact this isn't a real event, I'm almost positive it will
12319            * never trigger a drag event.  maybe_drag is the only function that uses
12320            * more than just event.x and event.y. */
12321           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
12322         }
12323     }
12324
12325   return TRUE;
12326 }
12327
12328 /**
12329  * gtk_tree_view_collapse_row:
12330  * @tree_view: a #GtkTreeView
12331  * @path: path to a row in the @tree_view
12332  *
12333  * Collapses a row (hides its child rows, if they exist).
12334  *
12335  * Return value: %TRUE if the row was collapsed.
12336  **/
12337 gboolean
12338 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
12339                             GtkTreePath *path)
12340 {
12341   GtkRBTree *tree;
12342   GtkRBNode *node;
12343
12344   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12345   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
12346   g_return_val_if_fail (path != NULL, FALSE);
12347
12348   if (_gtk_tree_view_find_node (tree_view,
12349                                 path,
12350                                 &tree,
12351                                 &node))
12352     return FALSE;
12353
12354   if (tree == NULL || node->children == NULL)
12355     return FALSE;
12356
12357   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12358 }
12359
12360 static void
12361 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
12362                                         GtkRBTree              *tree,
12363                                         GtkTreePath            *path,
12364                                         GtkTreeViewMappingFunc  func,
12365                                         gpointer                user_data)
12366 {
12367   GtkRBNode *node;
12368
12369   if (tree == NULL || tree->root == NULL)
12370     return;
12371
12372   node = tree->root;
12373
12374   while (node && node->left != tree->nil)
12375     node = node->left;
12376
12377   while (node)
12378     {
12379       if (node->children)
12380         {
12381           (* func) (tree_view, path, user_data);
12382           gtk_tree_path_down (path);
12383           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
12384           gtk_tree_path_up (path);
12385         }
12386       gtk_tree_path_next (path);
12387       node = _gtk_rbtree_next (tree, node);
12388     }
12389 }
12390
12391 /**
12392  * gtk_tree_view_map_expanded_rows:
12393  * @tree_view: A #GtkTreeView
12394  * @func: A function to be called
12395  * @data: User data to be passed to the function.
12396  *
12397  * Calls @func on all expanded rows.
12398  **/
12399 void
12400 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
12401                                  GtkTreeViewMappingFunc  func,
12402                                  gpointer                user_data)
12403 {
12404   GtkTreePath *path;
12405
12406   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12407   g_return_if_fail (func != NULL);
12408
12409   path = gtk_tree_path_new_first ();
12410
12411   gtk_tree_view_map_expanded_rows_helper (tree_view,
12412                                           tree_view->priv->tree,
12413                                           path, func, user_data);
12414
12415   gtk_tree_path_free (path);
12416 }
12417
12418 /**
12419  * gtk_tree_view_row_expanded:
12420  * @tree_view: A #GtkTreeView.
12421  * @path: A #GtkTreePath to test expansion state.
12422  *
12423  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
12424  *
12425  * Return value: %TRUE if #path is expanded.
12426  **/
12427 gboolean
12428 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
12429                             GtkTreePath *path)
12430 {
12431   GtkRBTree *tree;
12432   GtkRBNode *node;
12433
12434   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12435   g_return_val_if_fail (path != NULL, FALSE);
12436
12437   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12438
12439   if (node == NULL)
12440     return FALSE;
12441
12442   return (node->children != NULL);
12443 }
12444
12445 /**
12446  * gtk_tree_view_get_reorderable:
12447  * @tree_view: a #GtkTreeView
12448  *
12449  * Retrieves whether the user can reorder the tree via drag-and-drop. See
12450  * gtk_tree_view_set_reorderable().
12451  *
12452  * Return value: %TRUE if the tree can be reordered.
12453  **/
12454 gboolean
12455 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
12456 {
12457   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12458
12459   return tree_view->priv->reorderable;
12460 }
12461
12462 /**
12463  * gtk_tree_view_set_reorderable:
12464  * @tree_view: A #GtkTreeView.
12465  * @reorderable: %TRUE, if the tree can be reordered.
12466  *
12467  * This function is a convenience function to allow you to reorder
12468  * models that support the #GtkDragSourceIface and the
12469  * #GtkDragDestIface.  Both #GtkTreeStore and #GtkListStore support
12470  * these.  If @reorderable is %TRUE, then the user can reorder the
12471  * model by dragging and dropping rows. The developer can listen to
12472  * these changes by connecting to the model's row_inserted and
12473  * row_deleted signals. The reordering is implemented by setting up
12474  * the tree view as a drag source and destination. Therefore, drag and
12475  * drop can not be used in a reorderable view for any other purpose.
12476  *
12477  * This function does not give you any degree of control over the order -- any
12478  * reordering is allowed.  If more control is needed, you should probably
12479  * handle drag and drop manually.
12480  **/
12481 void
12482 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
12483                                gboolean     reorderable)
12484 {
12485   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12486
12487   reorderable = reorderable != FALSE;
12488
12489   if (tree_view->priv->reorderable == reorderable)
12490     return;
12491
12492   if (reorderable)
12493     {
12494       const GtkTargetEntry row_targets[] = {
12495         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
12496       };
12497
12498       gtk_tree_view_enable_model_drag_source (tree_view,
12499                                               GDK_BUTTON1_MASK,
12500                                               row_targets,
12501                                               G_N_ELEMENTS (row_targets),
12502                                               GDK_ACTION_MOVE);
12503       gtk_tree_view_enable_model_drag_dest (tree_view,
12504                                             row_targets,
12505                                             G_N_ELEMENTS (row_targets),
12506                                             GDK_ACTION_MOVE);
12507     }
12508   else
12509     {
12510       gtk_tree_view_unset_rows_drag_source (tree_view);
12511       gtk_tree_view_unset_rows_drag_dest (tree_view);
12512     }
12513
12514   tree_view->priv->reorderable = reorderable;
12515
12516   g_object_notify (G_OBJECT (tree_view), "reorderable");
12517 }
12518
12519 static void
12520 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
12521                                GtkTreePath     *path,
12522                                gboolean         clear_and_select,
12523                                gboolean         clamp_node)
12524 {
12525   GtkRBTree *tree = NULL;
12526   GtkRBNode *node = NULL;
12527
12528   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12529     {
12530       GtkTreePath *cursor_path;
12531       cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12532       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
12533       gtk_tree_path_free (cursor_path);
12534     }
12535
12536   gtk_tree_row_reference_free (tree_view->priv->cursor);
12537   tree_view->priv->cursor = NULL;
12538
12539   /* One cannot set the cursor on a separator. */
12540   if (!row_is_separator (tree_view, NULL, path))
12541     {
12542       tree_view->priv->cursor =
12543         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
12544                                           tree_view->priv->model,
12545                                           path);
12546       _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12547     }
12548
12549   if (tree != NULL)
12550     {
12551       GtkRBTree *new_tree = NULL;
12552       GtkRBNode *new_node = NULL;
12553
12554       if (clear_and_select && !tree_view->priv->ctrl_pressed)
12555         {
12556           GtkTreeSelectMode mode = 0;
12557
12558           if (tree_view->priv->ctrl_pressed)
12559             mode |= GTK_TREE_SELECT_MODE_TOGGLE;
12560           if (tree_view->priv->shift_pressed)
12561             mode |= GTK_TREE_SELECT_MODE_EXTEND;
12562
12563           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
12564                                                     node, tree, path, mode,
12565                                                     FALSE);
12566         }
12567
12568       /* We have to re-find tree and node here again, somebody might have
12569        * cleared the node or the whole tree in the GtkTreeSelection::changed
12570        * callback. If the nodes differ we bail out here.
12571        */
12572       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
12573
12574       if (tree != new_tree || node != new_node)
12575         return;
12576
12577       if (clamp_node)
12578         {
12579           gtk_tree_view_clamp_node_visible (tree_view, tree, node);
12580           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
12581         }
12582     }
12583
12584   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
12585 }
12586
12587 /**
12588  * gtk_tree_view_get_cursor:
12589  * @tree_view: A #GtkTreeView
12590  * @path: A pointer to be filled with the current cursor path, or %NULL
12591  * @focus_column: A pointer to be filled with the current focus column, or %NULL
12592  *
12593  * Fills in @path and @focus_column with the current path and focus column.  If
12594  * the cursor isn't currently set, then *@path will be %NULL.  If no column
12595  * currently has focus, then *@focus_column will be %NULL.
12596  *
12597  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
12598  * you are done with it.
12599  **/
12600 void
12601 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
12602                           GtkTreePath       **path,
12603                           GtkTreeViewColumn **focus_column)
12604 {
12605   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12606
12607   if (path)
12608     {
12609       if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12610         *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12611       else
12612         *path = NULL;
12613     }
12614
12615   if (focus_column)
12616     {
12617       *focus_column = tree_view->priv->focus_column;
12618     }
12619 }
12620
12621 /**
12622  * gtk_tree_view_set_cursor:
12623  * @tree_view: A #GtkTreeView
12624  * @path: A #GtkTreePath
12625  * @focus_column: A #GtkTreeViewColumn, or %NULL
12626  * @start_editing: %TRUE if the specified cell should start being edited.
12627  *
12628  * Sets the current keyboard focus to be at @path, and selects it.  This is
12629  * useful when you want to focus the user's attention on a particular row.  If
12630  * @focus_column is not %NULL, then focus is given to the column specified by
12631  * it. Additionally, if @focus_column is specified, and @start_editing is
12632  * %TRUE, then editing should be started in the specified cell.
12633  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
12634  * in order to give keyboard focus to the widget.  Please note that editing
12635  * can only happen when the widget is realized.
12636  **/
12637 void
12638 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
12639                           GtkTreePath       *path,
12640                           GtkTreeViewColumn *focus_column,
12641                           gboolean           start_editing)
12642 {
12643   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
12644                                     NULL, start_editing);
12645 }
12646
12647 /**
12648  * gtk_tree_view_set_cursor_on_cell:
12649  * @tree_view: A #GtkTreeView
12650  * @path: A #GtkTreePath
12651  * @focus_column: A #GtkTreeViewColumn, or %NULL
12652  * @focus_cell: A #GtkCellRenderer, or %NULL
12653  * @start_editing: %TRUE if the specified cell should start being edited.
12654  *
12655  * Sets the current keyboard focus to be at @path, and selects it.  This is
12656  * useful when you want to focus the user's attention on a particular row.  If
12657  * @focus_column is not %NULL, then focus is given to the column specified by
12658  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
12659  * contains 2 or more editable or activatable cells, then focus is given to
12660  * the cell specified by @focus_cell. Additionally, if @focus_column is
12661  * specified, and @start_editing is %TRUE, then editing should be started in
12662  * the specified cell.  This function is often followed by
12663  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
12664  * widget.  Please note that editing can only happen when the widget is
12665  * realized.
12666  *
12667  * Since: 2.2
12668  **/
12669 void
12670 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
12671                                   GtkTreePath       *path,
12672                                   GtkTreeViewColumn *focus_column,
12673                                   GtkCellRenderer   *focus_cell,
12674                                   gboolean           start_editing)
12675 {
12676   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12677   g_return_if_fail (tree_view->priv->tree != NULL);
12678   g_return_if_fail (path != NULL);
12679   if (focus_column)
12680     g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (focus_column));
12681   if (focus_cell)
12682     {
12683       g_return_if_fail (focus_column);
12684       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
12685     }
12686
12687   /* cancel the current editing, if it exists */
12688   if (tree_view->priv->edited_column &&
12689       tree_view->priv->edited_column->editable_widget)
12690     gtk_tree_view_stop_editing (tree_view, TRUE);
12691
12692   gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
12693
12694   if (focus_column && focus_column->visible)
12695     {
12696       GList *list;
12697       gboolean column_in_tree = FALSE;
12698
12699       for (list = tree_view->priv->columns; list; list = list->next)
12700         if (list->data == focus_column)
12701           {
12702             column_in_tree = TRUE;
12703             break;
12704           }
12705       g_return_if_fail (column_in_tree);
12706       tree_view->priv->focus_column = focus_column;
12707       if (focus_cell)
12708         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
12709       if (start_editing)
12710         gtk_tree_view_start_editing (tree_view, path);
12711     }
12712 }
12713
12714 /**
12715  * gtk_tree_view_get_bin_window:
12716  * @tree_view: A #GtkTreeView
12717  *
12718  * Returns the window that @tree_view renders to.  This is used primarily to
12719  * compare to <literal>event->window</literal> to confirm that the event on
12720  * @tree_view is on the right window.
12721  *
12722  * Return value: A #GdkWindow, or %NULL when @tree_view hasn't been realized yet
12723  **/
12724 GdkWindow *
12725 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
12726 {
12727   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12728
12729   return tree_view->priv->bin_window;
12730 }
12731
12732 /**
12733  * gtk_tree_view_get_path_at_pos:
12734  * @tree_view: A #GtkTreeView.
12735  * @x: The x position to be identified (relative to bin_window).
12736  * @y: The y position to be identified (relative to bin_window).
12737  * @path: A pointer to a #GtkTreePath pointer to be filled in, or %NULL
12738  * @column: A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
12739  * @cell_x: A pointer where the X coordinate relative to the cell can be placed, or %NULL
12740  * @cell_y: A pointer where the Y coordinate relative to the cell can be placed, or %NULL
12741  *
12742  * Finds the path at the point (@x, @y), relative to bin_window coordinates
12743  * (please see gtk_tree_view_get_bin_window()).
12744  * That is, @x and @y are relative to an events coordinates. @x and @y must
12745  * come from an event on the @tree_view only where <literal>event->window ==
12746  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
12747  * things like popup menus. If @path is non-%NULL, then it will be filled
12748  * with the #GtkTreePath at that point.  This path should be freed with
12749  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
12750  * with the column at that point.  @cell_x and @cell_y return the coordinates
12751  * relative to the cell background (i.e. the @background_area passed to
12752  * gtk_cell_renderer_render()).  This function is only meaningful if
12753  * @tree_view is realized.
12754  *
12755  * For converting widget coordinates (eg. the ones you get from
12756  * GtkWidget::query-tooltip), please see
12757  * gtk_tree_view_convert_widget_to_bin_window_coords().
12758  *
12759  * Return value: %TRUE if a row exists at that coordinate.
12760  **/
12761 gboolean
12762 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
12763                                gint                x,
12764                                gint                y,
12765                                GtkTreePath       **path,
12766                                GtkTreeViewColumn **column,
12767                                gint               *cell_x,
12768                                gint               *cell_y)
12769 {
12770   GtkRBTree *tree;
12771   GtkRBNode *node;
12772   gint y_offset;
12773
12774   g_return_val_if_fail (tree_view != NULL, FALSE);
12775   g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
12776
12777   if (path)
12778     *path = NULL;
12779   if (column)
12780     *column = NULL;
12781
12782   if (tree_view->priv->tree == NULL)
12783     return FALSE;
12784
12785   if (x > tree_view->priv->hadjustment->upper)
12786     return FALSE;
12787
12788   if (x < 0 || y < 0)
12789     return FALSE;
12790
12791   if (column || cell_x)
12792     {
12793       GtkTreeViewColumn *tmp_column;
12794       GtkTreeViewColumn *last_column = NULL;
12795       GList *list;
12796       gint remaining_x = x;
12797       gboolean found = FALSE;
12798       gboolean rtl;
12799
12800       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
12801       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
12802            list;
12803            list = (rtl ? list->prev : list->next))
12804         {
12805           tmp_column = list->data;
12806
12807           if (tmp_column->visible == FALSE)
12808             continue;
12809
12810           last_column = tmp_column;
12811           if (remaining_x <= tmp_column->width)
12812             {
12813               found = TRUE;
12814
12815               if (column)
12816                 *column = tmp_column;
12817
12818               if (cell_x)
12819                 *cell_x = remaining_x;
12820
12821               break;
12822             }
12823           remaining_x -= tmp_column->width;
12824         }
12825
12826       /* If found is FALSE and there is a last_column, then it the remainder
12827        * space is in that area
12828        */
12829       if (!found)
12830         {
12831           if (last_column)
12832             {
12833               if (column)
12834                 *column = last_column;
12835
12836               if (cell_x)
12837                 *cell_x = last_column->width + remaining_x;
12838             }
12839           else
12840             {
12841               return FALSE;
12842             }
12843         }
12844     }
12845
12846   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
12847                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
12848                                       &tree, &node);
12849
12850   if (tree == NULL)
12851     return FALSE;
12852
12853   if (cell_y)
12854     *cell_y = y_offset;
12855
12856   if (path)
12857     *path = _gtk_tree_view_find_path (tree_view, tree, node);
12858
12859   return TRUE;
12860 }
12861
12862
12863 /**
12864  * gtk_tree_view_get_cell_area:
12865  * @tree_view: a #GtkTreeView
12866  * @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
12867  * @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
12868  * @rect: rectangle to fill with cell rect
12869  *
12870  * Fills the bounding rectangle in bin_window coordinates for the cell at the
12871  * row specified by @path and the column specified by @column.  If @path is
12872  * %NULL, or points to a path not currently displayed, the @y and @height fields
12873  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
12874  * fields will be filled with 0.  The sum of all cell rects does not cover the
12875  * entire tree; there are extra pixels in between rows, for example. The
12876  * returned rectangle is equivalent to the @cell_area passed to
12877  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
12878  * realized.
12879  **/
12880 void
12881 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
12882                              GtkTreePath        *path,
12883                              GtkTreeViewColumn  *column,
12884                              GdkRectangle       *rect)
12885 {
12886   GtkRBTree *tree = NULL;
12887   GtkRBNode *node = NULL;
12888   gint vertical_separator;
12889   gint horizontal_separator;
12890
12891   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12892   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12893   g_return_if_fail (rect != NULL);
12894   g_return_if_fail (!column || column->tree_view == (GtkWidget *) tree_view);
12895   g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
12896
12897   gtk_widget_style_get (GTK_WIDGET (tree_view),
12898                         "vertical-separator", &vertical_separator,
12899                         "horizontal-separator", &horizontal_separator,
12900                         NULL);
12901
12902   rect->x = 0;
12903   rect->y = 0;
12904   rect->width = 0;
12905   rect->height = 0;
12906
12907   if (column)
12908     {
12909       rect->x = column->button->allocation.x + horizontal_separator/2;
12910       rect->width = column->button->allocation.width - horizontal_separator;
12911     }
12912
12913   if (path)
12914     {
12915       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12916
12917       /* Get vertical coords */
12918       if ((!ret && tree == NULL) || ret)
12919         return;
12920
12921       rect->y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
12922       rect->height = MAX (CELL_HEIGHT (node, vertical_separator), tree_view->priv->expander_size - vertical_separator);
12923
12924       if (column &&
12925           gtk_tree_view_is_expander_column (tree_view, column))
12926         {
12927           gint depth = gtk_tree_path_get_depth (path);
12928           gboolean rtl;
12929
12930           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
12931
12932           if (!rtl)
12933             rect->x += (depth - 1) * tree_view->priv->level_indentation;
12934           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
12935
12936           if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
12937             {
12938               if (!rtl)
12939                 rect->x += depth * tree_view->priv->expander_size;
12940               rect->width -= depth * tree_view->priv->expander_size;
12941             }
12942
12943           rect->width = MAX (rect->width, 0);
12944         }
12945     }
12946 }
12947
12948 /**
12949  * gtk_tree_view_get_background_area:
12950  * @tree_view: a #GtkTreeView
12951  * @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
12952  * @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
12953  * @rect: rectangle to fill with cell background rect
12954  *
12955  * Fills the bounding rectangle in bin_window coordinates for the cell at the
12956  * row specified by @path and the column specified by @column.  If @path is
12957  * %NULL, or points to a node not found in the tree, the @y and @height fields of
12958  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
12959  * fields will be filled with 0.  The returned rectangle is equivalent to the
12960  * @background_area passed to gtk_cell_renderer_render().  These background
12961  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
12962  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
12963  * itself, excluding surrounding borders and the tree expander area.
12964  *
12965  **/
12966 void
12967 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
12968                                    GtkTreePath        *path,
12969                                    GtkTreeViewColumn  *column,
12970                                    GdkRectangle       *rect)
12971 {
12972   GtkRBTree *tree = NULL;
12973   GtkRBNode *node = NULL;
12974
12975   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12976   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12977   g_return_if_fail (rect != NULL);
12978
12979   rect->x = 0;
12980   rect->y = 0;
12981   rect->width = 0;
12982   rect->height = 0;
12983
12984   if (path)
12985     {
12986       /* Get vertical coords */
12987
12988       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
12989           tree == NULL)
12990         return;
12991
12992       rect->y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
12993
12994       rect->height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
12995     }
12996
12997   if (column)
12998     {
12999       gint x2 = 0;
13000
13001       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
13002       rect->width = x2 - rect->x;
13003     }
13004 }
13005
13006 /**
13007  * gtk_tree_view_get_visible_rect:
13008  * @tree_view: a #GtkTreeView
13009  * @visible_rect: rectangle to fill
13010  *
13011  * Fills @visible_rect with the currently-visible region of the
13012  * buffer, in tree coordinates. Convert to bin_window coordinates with
13013  * gtk_tree_view_convert_tree_to_bin_window_coords().
13014  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
13015  * scrollable area of the tree.
13016  **/
13017 void
13018 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
13019                                 GdkRectangle *visible_rect)
13020 {
13021   GtkWidget *widget;
13022
13023   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13024
13025   widget = GTK_WIDGET (tree_view);
13026
13027   if (visible_rect)
13028     {
13029       visible_rect->x = tree_view->priv->hadjustment->value;
13030       visible_rect->y = tree_view->priv->vadjustment->value;
13031       visible_rect->width = widget->allocation.width;
13032       visible_rect->height = widget->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
13033     }
13034 }
13035
13036 /**
13037  * gtk_tree_view_widget_to_tree_coords:
13038  * @tree_view: a #GtkTreeView
13039  * @wx: X coordinate relative to bin_window
13040  * @wy: Y coordinate relative to bin_window
13041  * @tx: return location for tree X coordinate
13042  * @ty: return location for tree Y coordinate
13043  *
13044  * Converts bin_window coordinates to coordinates for the
13045  * tree (the full scrollable area of the tree).
13046  *
13047  * Deprecated: 2.12: Due to historial reasons the name of this function is
13048  * incorrect.  For converting coordinates relative to the widget to
13049  * bin_window coordinates, please see
13050  * gtk_tree_view_convert_widget_to_bin_window_coords().
13051  *
13052  **/
13053 void
13054 gtk_tree_view_widget_to_tree_coords (GtkTreeView *tree_view,
13055                                       gint         wx,
13056                                       gint         wy,
13057                                       gint        *tx,
13058                                       gint        *ty)
13059 {
13060   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13061
13062   if (tx)
13063     *tx = wx + tree_view->priv->hadjustment->value;
13064   if (ty)
13065     *ty = wy + tree_view->priv->dy;
13066 }
13067
13068 /**
13069  * gtk_tree_view_tree_to_widget_coords:
13070  * @tree_view: a #GtkTreeView
13071  * @tx: tree X coordinate
13072  * @ty: tree Y coordinate
13073  * @wx: return location for X coordinate relative to bin_window
13074  * @wy: return location for Y coordinate relative to bin_window
13075  *
13076  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13077  * to bin_window coordinates.
13078  *
13079  * Deprecated: 2.12: Due to historial reasons the name of this function is
13080  * incorrect.  For converting bin_window coordinates to coordinates relative
13081  * to bin_window, please see
13082  * gtk_tree_view_convert_bin_window_to_widget_coords().
13083  *
13084  **/
13085 void
13086 gtk_tree_view_tree_to_widget_coords (GtkTreeView *tree_view,
13087                                      gint         tx,
13088                                      gint         ty,
13089                                      gint        *wx,
13090                                      gint        *wy)
13091 {
13092   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13093
13094   if (wx)
13095     *wx = tx - tree_view->priv->hadjustment->value;
13096   if (wy)
13097     *wy = ty - tree_view->priv->dy;
13098 }
13099
13100
13101 /**
13102  * gtk_tree_view_convert_widget_to_tree_coords:
13103  * @tree_view: a #GtkTreeView
13104  * @wx: X coordinate relative to the widget
13105  * @wy: Y coordinate relative to the widget
13106  * @tx: return location for tree X coordinate
13107  * @ty: return location for tree Y coordinate
13108  *
13109  * Converts widget coordinates to coordinates for the
13110  * tree (the full scrollable area of the tree).
13111  *
13112  * Since: 2.12
13113  **/
13114 void
13115 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13116                                              gint         wx,
13117                                              gint         wy,
13118                                              gint        *tx,
13119                                              gint        *ty)
13120 {
13121   gint x, y;
13122
13123   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13124
13125   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13126                                                      wx, wy,
13127                                                      &x, &y);
13128   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13129                                                    x, y,
13130                                                    tx, ty);
13131 }
13132
13133 /**
13134  * gtk_tree_view_convert_tree_to_widget_coords:
13135  * @tree_view: a #GtkTreeView
13136  * @tx: X coordinate relative to the tree
13137  * @ty: Y coordinate relative to the tree
13138  * @wx: return location for widget X coordinate
13139  * @wy: return location for widget Y coordinate
13140  *
13141  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13142  * to widget coordinates.
13143  *
13144  * Since: 2.12
13145  **/
13146 void
13147 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13148                                              gint         tx,
13149                                              gint         ty,
13150                                              gint        *wx,
13151                                              gint        *wy)
13152 {
13153   gint x, y;
13154
13155   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13156
13157   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13158                                                    tx, ty,
13159                                                    &x, &y);
13160   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13161                                                      x, y,
13162                                                      wx, wy);
13163 }
13164
13165 /**
13166  * gtk_tree_view_convert_widget_to_bin_window_coords:
13167  * @tree_view: a #GtkTreeView
13168  * @wx: X coordinate relative to the widget
13169  * @wy: Y coordinate relative to the widget
13170  * @bx: return location for bin_window X coordinate
13171  * @by: return location for bin_window Y coordinate
13172  *
13173  * Converts widget coordinates to coordinates for the bin_window
13174  * (see gtk_tree_view_get_bin_window()).
13175  *
13176  * Since: 2.12
13177  **/
13178 void
13179 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13180                                                    gint         wx,
13181                                                    gint         wy,
13182                                                    gint        *bx,
13183                                                    gint        *by)
13184 {
13185   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13186
13187   if (bx)
13188     *bx = wx + tree_view->priv->hadjustment->value;
13189   if (by)
13190     *by = wy - TREE_VIEW_HEADER_HEIGHT (tree_view);
13191 }
13192
13193 /**
13194  * gtk_tree_view_convert_bin_window_to_widget_coords:
13195  * @tree_view: a #GtkTreeView
13196  * @bx: bin_window X coordinate
13197  * @by: bin_window Y coordinate
13198  * @wx: return location for widget X coordinate
13199  * @wy: return location for widget Y coordinate
13200  *
13201  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13202  * to widget relative coordinates.
13203  *
13204  * Since: 2.12
13205  **/
13206 void
13207 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13208                                                    gint         bx,
13209                                                    gint         by,
13210                                                    gint        *wx,
13211                                                    gint        *wy)
13212 {
13213   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13214
13215   if (wx)
13216     *wx = bx - tree_view->priv->hadjustment->value;
13217   if (wy)
13218     *wy = by + TREE_VIEW_HEADER_HEIGHT (tree_view);
13219 }
13220
13221 /**
13222  * gtk_tree_view_convert_tree_to_bin_window_coords:
13223  * @tree_view: a #GtkTreeView
13224  * @tx: tree X coordinate
13225  * @ty: tree Y coordinate
13226  * @bx: return location for X coordinate relative to bin_window
13227  * @by: return location for Y coordinate relative to bin_window
13228  *
13229  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13230  * to bin_window coordinates.
13231  *
13232  * Since: 2.12
13233  **/
13234 void
13235 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13236                                                  gint         tx,
13237                                                  gint         ty,
13238                                                  gint        *bx,
13239                                                  gint        *by)
13240 {
13241   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13242
13243   if (bx)
13244     *bx = tx;
13245   if (by)
13246     *by = ty - tree_view->priv->dy;
13247 }
13248
13249 /**
13250  * gtk_tree_view_convert_bin_window_to_tree_coords:
13251  * @tree_view: a #GtkTreeView
13252  * @bx: X coordinate relative to bin_window
13253  * @by: Y coordinate relative to bin_window
13254  * @tx: return location for tree X coordinate
13255  * @ty: return location for tree Y coordinate
13256  *
13257  * Converts bin_window coordinates to coordinates for the
13258  * tree (the full scrollable area of the tree).
13259  *
13260  * Since: 2.12
13261  **/
13262 void
13263 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
13264                                                  gint         bx,
13265                                                  gint         by,
13266                                                  gint        *tx,
13267                                                  gint        *ty)
13268 {
13269   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13270
13271   if (tx)
13272     *tx = bx;
13273   if (ty)
13274     *ty = by + tree_view->priv->dy;
13275 }
13276
13277
13278
13279 /**
13280  * gtk_tree_view_get_visible_range:
13281  * @tree_view: A #GtkTreeView
13282  * @start_path: Return location for start of region, or %NULL.
13283  * @end_path: Return location for end of region, or %NULL.
13284  *
13285  * Sets @start_path and @end_path to be the first and last visible path.
13286  * Note that there may be invisible paths in between.
13287  *
13288  * The paths should be freed with gtk_tree_path_free() after use.
13289  *
13290  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
13291  *
13292  * Since: 2.8
13293  **/
13294 gboolean
13295 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
13296                                  GtkTreePath **start_path,
13297                                  GtkTreePath **end_path)
13298 {
13299   GtkRBTree *tree;
13300   GtkRBNode *node;
13301   gboolean retval;
13302
13303   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13304
13305   if (!tree_view->priv->tree)
13306     return FALSE;
13307
13308   retval = TRUE;
13309
13310   if (start_path)
13311     {
13312       _gtk_rbtree_find_offset (tree_view->priv->tree,
13313                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
13314                                &tree, &node);
13315       if (node)
13316         *start_path = _gtk_tree_view_find_path (tree_view, tree, node);
13317       else
13318         retval = FALSE;
13319     }
13320
13321   if (end_path)
13322     {
13323       gint y;
13324
13325       if (tree_view->priv->height < tree_view->priv->vadjustment->page_size)
13326         y = tree_view->priv->height - 1;
13327       else
13328         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, tree_view->priv->vadjustment->page_size) - 1;
13329
13330       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
13331       if (node)
13332         *end_path = _gtk_tree_view_find_path (tree_view, tree, node);
13333       else
13334         retval = FALSE;
13335     }
13336
13337   return retval;
13338 }
13339
13340 static void
13341 unset_reorderable (GtkTreeView *tree_view)
13342 {
13343   if (tree_view->priv->reorderable)
13344     {
13345       tree_view->priv->reorderable = FALSE;
13346       g_object_notify (G_OBJECT (tree_view), "reorderable");
13347     }
13348 }
13349
13350 /**
13351  * gtk_tree_view_enable_model_drag_source:
13352  * @tree_view: a #GtkTreeView
13353  * @start_button_mask: Mask of allowed buttons to start drag
13354  * @targets: the table of targets that the drag will support
13355  * @n_targets: the number of items in @targets
13356  * @actions: the bitmask of possible actions for a drag from this
13357  *    widget
13358  *
13359  * Turns @tree_view into a drag source for automatic DND. Calling this
13360  * method sets reorderable to %FALSE.
13361  **/
13362 void
13363 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
13364                                         GdkModifierType           start_button_mask,
13365                                         const GtkTargetEntry     *targets,
13366                                         gint                      n_targets,
13367                                         GdkDragAction             actions)
13368 {
13369   TreeViewDragInfo *di;
13370
13371   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13372
13373   gtk_drag_source_set (GTK_WIDGET (tree_view),
13374                        0,
13375                        targets,
13376                        n_targets,
13377                        actions);
13378
13379   di = ensure_info (tree_view);
13380
13381   di->start_button_mask = start_button_mask;
13382   di->source_actions = actions;
13383   di->source_set = TRUE;
13384
13385   unset_reorderable (tree_view);
13386 }
13387
13388 /**
13389  * gtk_tree_view_enable_model_drag_dest:
13390  * @tree_view: a #GtkTreeView
13391  * @targets: the table of targets that the drag will support
13392  * @n_targets: the number of items in @targets
13393  * @actions: the bitmask of possible actions for a drag from this
13394  *    widget
13395  *
13396  * Turns @tree_view into a drop destination for automatic DND. Calling
13397  * this method sets reorderable to %FALSE.
13398  **/
13399 void
13400 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
13401                                       const GtkTargetEntry     *targets,
13402                                       gint                      n_targets,
13403                                       GdkDragAction             actions)
13404 {
13405   TreeViewDragInfo *di;
13406
13407   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13408
13409   gtk_drag_dest_set (GTK_WIDGET (tree_view),
13410                      0,
13411                      targets,
13412                      n_targets,
13413                      actions);
13414
13415   di = ensure_info (tree_view);
13416   di->dest_set = TRUE;
13417
13418   unset_reorderable (tree_view);
13419 }
13420
13421 /**
13422  * gtk_tree_view_unset_rows_drag_source:
13423  * @tree_view: a #GtkTreeView
13424  *
13425  * Undoes the effect of
13426  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
13427  * reorderable to %FALSE.
13428  **/
13429 void
13430 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
13431 {
13432   TreeViewDragInfo *di;
13433
13434   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13435
13436   di = get_info (tree_view);
13437
13438   if (di)
13439     {
13440       if (di->source_set)
13441         {
13442           gtk_drag_source_unset (GTK_WIDGET (tree_view));
13443           di->source_set = FALSE;
13444         }
13445
13446       if (!di->dest_set && !di->source_set)
13447         remove_info (tree_view);
13448     }
13449
13450   unset_reorderable (tree_view);
13451 }
13452
13453 /**
13454  * gtk_tree_view_unset_rows_drag_dest:
13455  * @tree_view: a #GtkTreeView
13456  *
13457  * Undoes the effect of
13458  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
13459  * reorderable to %FALSE.
13460  **/
13461 void
13462 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
13463 {
13464   TreeViewDragInfo *di;
13465
13466   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13467
13468   di = get_info (tree_view);
13469
13470   if (di)
13471     {
13472       if (di->dest_set)
13473         {
13474           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
13475           di->dest_set = FALSE;
13476         }
13477
13478       if (!di->dest_set && !di->source_set)
13479         remove_info (tree_view);
13480     }
13481
13482   unset_reorderable (tree_view);
13483 }
13484
13485 /**
13486  * gtk_tree_view_set_drag_dest_row:
13487  * @tree_view: a #GtkTreeView
13488  * @path: The path of the row to highlight, or %NULL.
13489  * @pos: Specifies whether to drop before, after or into the row
13490  *
13491  * Sets the row that is highlighted for feedback.
13492  **/
13493 void
13494 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
13495                                  GtkTreePath            *path,
13496                                  GtkTreeViewDropPosition pos)
13497 {
13498   GtkTreePath *current_dest;
13499
13500   /* Note; this function is exported to allow a custom DND
13501    * implementation, so it can't touch TreeViewDragInfo
13502    */
13503
13504   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13505
13506   current_dest = NULL;
13507
13508   if (tree_view->priv->drag_dest_row)
13509     {
13510       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
13511       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
13512     }
13513
13514   /* special case a drop on an empty model */
13515   tree_view->priv->empty_view_drop = 0;
13516
13517   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
13518       && gtk_tree_path_get_depth (path) == 1
13519       && gtk_tree_path_get_indices (path)[0] == 0)
13520     {
13521       gint n_children;
13522
13523       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
13524                                                    NULL);
13525
13526       if (!n_children)
13527         tree_view->priv->empty_view_drop = 1;
13528     }
13529
13530   tree_view->priv->drag_dest_pos = pos;
13531
13532   if (path)
13533     {
13534       tree_view->priv->drag_dest_row =
13535         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
13536       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
13537     }
13538   else
13539     tree_view->priv->drag_dest_row = NULL;
13540
13541   if (current_dest)
13542     {
13543       GtkRBTree *tree, *new_tree;
13544       GtkRBNode *node, *new_node;
13545
13546       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
13547       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
13548
13549       if (tree && node)
13550         {
13551           _gtk_rbtree_next_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_rbtree_prev_full (tree, node, &new_tree, &new_node);
13556           if (new_tree && new_node)
13557             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
13558         }
13559       gtk_tree_path_free (current_dest);
13560     }
13561 }
13562
13563 /**
13564  * gtk_tree_view_get_drag_dest_row:
13565  * @tree_view: a #GtkTreeView
13566  * @path: Return location for the path of the highlighted row, or %NULL.
13567  * @pos: Return location for the drop position, or %NULL
13568  *
13569  * Gets information about the row that is highlighted for feedback.
13570  **/
13571 void
13572 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
13573                                  GtkTreePath             **path,
13574                                  GtkTreeViewDropPosition  *pos)
13575 {
13576   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13577
13578   if (path)
13579     {
13580       if (tree_view->priv->drag_dest_row)
13581         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
13582       else
13583         {
13584           if (tree_view->priv->empty_view_drop)
13585             *path = gtk_tree_path_new_from_indices (0, -1);
13586           else
13587             *path = NULL;
13588         }
13589     }
13590
13591   if (pos)
13592     *pos = tree_view->priv->drag_dest_pos;
13593 }
13594
13595 /**
13596  * gtk_tree_view_get_dest_row_at_pos:
13597  * @tree_view: a #GtkTreeView
13598  * @drag_x: the position to determine the destination row for
13599  * @drag_y: the position to determine the destination row for
13600  * @path: Return location for the path of the highlighted row, or %NULL.
13601  * @pos: Return location for the drop position, or %NULL
13602  *
13603  * Determines the destination row for a given position.  @drag_x and
13604  * @drag_y are expected to be in widget coordinates.
13605  *
13606  * Return value: whether there is a row at the given position.
13607  **/
13608 gboolean
13609 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
13610                                    gint                     drag_x,
13611                                    gint                     drag_y,
13612                                    GtkTreePath            **path,
13613                                    GtkTreeViewDropPosition *pos)
13614 {
13615   gint cell_y;
13616   gint bin_x, bin_y;
13617   gdouble offset_into_row;
13618   gdouble third;
13619   GdkRectangle cell;
13620   GtkTreeViewColumn *column = NULL;
13621   GtkTreePath *tmp_path = NULL;
13622
13623   /* Note; this function is exported to allow a custom DND
13624    * implementation, so it can't touch TreeViewDragInfo
13625    */
13626
13627   g_return_val_if_fail (tree_view != NULL, FALSE);
13628   g_return_val_if_fail (drag_x >= 0, FALSE);
13629   g_return_val_if_fail (drag_y >= 0, FALSE);
13630   g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
13631
13632
13633   if (path)
13634     *path = NULL;
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 #GdkPixmap representation of the row at @path.
13701  * This image is used for a drag icon.
13702  *
13703  * Return value: a newly-allocated pixmap of the drag icon.
13704  **/
13705 GdkPixmap *
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   gint cell_offset;
13713   GList *list;
13714   GdkRectangle background_area;
13715   GdkRectangle expose_area;
13716   GtkWidget *widget;
13717   gint depth;
13718   /* start drawing inside the black outline */
13719   gint x = 1, y = 1;
13720   GdkDrawable *drawable;
13721   gint bin_window_width;
13722   gboolean is_separator = FALSE;
13723   gboolean rtl;
13724
13725   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13726   g_return_val_if_fail (path != NULL, NULL);
13727
13728   widget = GTK_WIDGET (tree_view);
13729
13730   if (!GTK_WIDGET_REALIZED (tree_view))
13731     return NULL;
13732
13733   depth = gtk_tree_path_get_depth (path);
13734
13735   _gtk_tree_view_find_node (tree_view,
13736                             path,
13737                             &tree,
13738                             &node);
13739
13740   if (tree == NULL)
13741     return NULL;
13742
13743   if (!gtk_tree_model_get_iter (tree_view->priv->model,
13744                                 &iter,
13745                                 path))
13746     return NULL;
13747
13748   is_separator = row_is_separator (tree_view, &iter, NULL);
13749
13750   cell_offset = x;
13751
13752   background_area.y = y;
13753   background_area.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
13754
13755   gdk_drawable_get_size (tree_view->priv->bin_window,
13756                          &bin_window_width, NULL);
13757
13758   drawable = gdk_pixmap_new (tree_view->priv->bin_window,
13759                              bin_window_width + 2,
13760                              background_area.height + 2,
13761                              -1);
13762
13763   expose_area.x = 0;
13764   expose_area.y = 0;
13765   expose_area.width = bin_window_width + 2;
13766   expose_area.height = background_area.height + 2;
13767
13768   gdk_draw_rectangle (drawable,
13769                       widget->style->base_gc [GTK_WIDGET_STATE (widget)],
13770                       TRUE,
13771                       0, 0,
13772                       bin_window_width + 2,
13773                       background_area.height + 2);
13774
13775   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13776
13777   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13778       list;
13779       list = (rtl ? list->prev : list->next))
13780     {
13781       GtkTreeViewColumn *column = list->data;
13782       GdkRectangle cell_area;
13783       gint vertical_separator;
13784
13785       if (!column->visible)
13786         continue;
13787
13788       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
13789                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
13790                                                node->children?TRUE:FALSE);
13791
13792       background_area.x = cell_offset;
13793       background_area.width = column->width;
13794
13795       gtk_widget_style_get (widget,
13796                             "vertical-separator", &vertical_separator,
13797                             NULL);
13798
13799       cell_area = background_area;
13800
13801       cell_area.y += vertical_separator / 2;
13802       cell_area.height -= vertical_separator;
13803
13804       if (gtk_tree_view_is_expander_column (tree_view, column))
13805         {
13806           if (!rtl)
13807             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
13808           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
13809
13810           if (TREE_VIEW_DRAW_EXPANDERS(tree_view))
13811             {
13812               if (!rtl)
13813                 cell_area.x += depth * tree_view->priv->expander_size;
13814               cell_area.width -= depth * tree_view->priv->expander_size;
13815             }
13816         }
13817
13818       if (gtk_tree_view_column_cell_is_visible (column))
13819         {
13820           if (is_separator)
13821             gtk_paint_hline (widget->style,
13822                              drawable,
13823                              GTK_STATE_NORMAL,
13824                              &cell_area,
13825                              widget,
13826                              NULL,
13827                              cell_area.x,
13828                              cell_area.x + cell_area.width,
13829                              cell_area.y + cell_area.height / 2);
13830           else
13831             _gtk_tree_view_column_cell_render (column,
13832                                                drawable,
13833                                                &background_area,
13834                                                &cell_area,
13835                                                &expose_area,
13836                                                0);
13837         }
13838       cell_offset += column->width;
13839     }
13840
13841   gdk_draw_rectangle (drawable,
13842                       widget->style->black_gc,
13843                       FALSE,
13844                       0, 0,
13845                       bin_window_width + 1,
13846                       background_area.height + 1);
13847
13848   return drawable;
13849 }
13850
13851
13852 /**
13853  * gtk_tree_view_set_destroy_count_func:
13854  * @tree_view: A #GtkTreeView
13855  * @func: Function to be called when a view row is destroyed, or %NULL
13856  * @data: User data to be passed to @func, or %NULL
13857  * @destroy: Destroy notifier for @data, or %NULL
13858  *
13859  * This function should almost never be used.  It is meant for private use by
13860  * ATK for determining the number of visible children that are removed when the
13861  * user collapses a row, or a row is deleted.
13862  **/
13863 void
13864 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
13865                                       GtkTreeDestroyCountFunc  func,
13866                                       gpointer                 data,
13867                                       GDestroyNotify           destroy)
13868 {
13869   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13870
13871   if (tree_view->priv->destroy_count_destroy)
13872     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
13873
13874   tree_view->priv->destroy_count_func = func;
13875   tree_view->priv->destroy_count_data = data;
13876   tree_view->priv->destroy_count_destroy = destroy;
13877 }
13878
13879
13880 /*
13881  * Interactive search
13882  */
13883
13884 /**
13885  * gtk_tree_view_set_enable_search:
13886  * @tree_view: A #GtkTreeView
13887  * @enable_search: %TRUE, if the user can search interactively
13888  *
13889  * If @enable_search is set, then the user can type in text to search through
13890  * the tree interactively (this is sometimes called "typeahead find").
13891  *
13892  * Note that even if this is %FALSE, the user can still initiate a search
13893  * using the "start-interactive-search" key binding.
13894  */
13895 void
13896 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
13897                                  gboolean     enable_search)
13898 {
13899   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13900
13901   enable_search = !!enable_search;
13902
13903   if (tree_view->priv->enable_search != enable_search)
13904     {
13905        tree_view->priv->enable_search = enable_search;
13906        g_object_notify (G_OBJECT (tree_view), "enable-search");
13907     }
13908 }
13909
13910 /**
13911  * gtk_tree_view_get_enable_search:
13912  * @tree_view: A #GtkTreeView
13913  *
13914  * Returns whether or not the tree allows to start interactive searching
13915  * by typing in text.
13916  *
13917  * Return value: whether or not to let the user search interactively
13918  */
13919 gboolean
13920 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
13921 {
13922   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13923
13924   return tree_view->priv->enable_search;
13925 }
13926
13927
13928 /**
13929  * gtk_tree_view_get_search_column:
13930  * @tree_view: A #GtkTreeView
13931  *
13932  * Gets the column searched on by the interactive search code.
13933  *
13934  * Return value: the column the interactive search code searches in.
13935  */
13936 gint
13937 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
13938 {
13939   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
13940
13941   return (tree_view->priv->search_column);
13942 }
13943
13944 /**
13945  * gtk_tree_view_set_search_column:
13946  * @tree_view: A #GtkTreeView
13947  * @column: the column of the model to search in, or -1 to disable searching
13948  *
13949  * Sets @column as the column where the interactive search code should
13950  * search in for the current model.
13951  *
13952  * If the search column is set, users can use the "start-interactive-search"
13953  * key binding to bring up search popup. The enable-search property controls
13954  * whether simply typing text will also start an interactive search.
13955  *
13956  * Note that @column refers to a column of the current model. The search
13957  * column is reset to -1 when the model is changed.
13958  */
13959 void
13960 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
13961                                  gint         column)
13962 {
13963   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13964   g_return_if_fail (column >= -1);
13965
13966   if (tree_view->priv->search_column == column)
13967     return;
13968
13969   tree_view->priv->search_column = column;
13970   g_object_notify (G_OBJECT (tree_view), "search-column");
13971 }
13972
13973 /**
13974  * gtk_tree_view_get_search_equal_func:
13975  * @tree_view: A #GtkTreeView
13976  *
13977  * Returns the compare function currently in use.
13978  *
13979  * Return value: the currently used compare function for the search code.
13980  */
13981
13982 GtkTreeViewSearchEqualFunc
13983 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
13984 {
13985   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13986
13987   return tree_view->priv->search_equal_func;
13988 }
13989
13990 /**
13991  * gtk_tree_view_set_search_equal_func:
13992  * @tree_view: A #GtkTreeView
13993  * @search_equal_func: the compare function to use during the search
13994  * @search_user_data: user data to pass to @search_equal_func, or %NULL
13995  * @search_destroy: Destroy notifier for @search_user_data, or %NULL
13996  *
13997  * Sets the compare function for the interactive search capabilities; note
13998  * that somewhat like strcmp() returning 0 for equality
13999  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
14000  **/
14001 void
14002 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14003                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14004                                      gpointer                    search_user_data,
14005                                      GDestroyNotify              search_destroy)
14006 {
14007   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14008   g_return_if_fail (search_equal_func != NULL);
14009
14010   if (tree_view->priv->search_destroy)
14011     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14012
14013   tree_view->priv->search_equal_func = search_equal_func;
14014   tree_view->priv->search_user_data = search_user_data;
14015   tree_view->priv->search_destroy = search_destroy;
14016   if (tree_view->priv->search_equal_func == NULL)
14017     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14018 }
14019
14020 /**
14021  * gtk_tree_view_get_search_entry:
14022  * @tree_view: A #GtkTreeView
14023  *
14024  * Returns the GtkEntry which is currently in use as interactive search
14025  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14026  * will be returned.
14027  *
14028  * Return value: the entry currently in use as search entry.
14029  *
14030  * Since: 2.10
14031  */
14032 GtkEntry *
14033 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14034 {
14035   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14036
14037   if (tree_view->priv->search_custom_entry_set)
14038     return GTK_ENTRY (tree_view->priv->search_entry);
14039
14040   return NULL;
14041 }
14042
14043 /**
14044  * gtk_tree_view_set_search_entry:
14045  * @tree_view: A #GtkTreeView
14046  * @entry: the entry the interactive search code of @tree_view should use or %NULL
14047  *
14048  * Sets the entry which the interactive search code will use for this
14049  * @tree_view.  This is useful when you want to provide a search entry
14050  * in our interface at all time at a fixed position.  Passing %NULL for
14051  * @entry will make the interactive search code use the built-in popup
14052  * entry again.
14053  *
14054  * Since: 2.10
14055  */
14056 void
14057 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14058                                 GtkEntry    *entry)
14059 {
14060   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14061   if (entry != NULL)
14062     g_return_if_fail (GTK_IS_ENTRY (entry));
14063
14064   if (tree_view->priv->search_custom_entry_set)
14065     {
14066       if (tree_view->priv->search_entry_changed_id)
14067         {
14068           g_signal_handler_disconnect (tree_view->priv->search_entry,
14069                                        tree_view->priv->search_entry_changed_id);
14070           tree_view->priv->search_entry_changed_id = 0;
14071         }
14072       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14073                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14074                                             tree_view);
14075
14076       g_object_unref (tree_view->priv->search_entry);
14077     }
14078   else if (tree_view->priv->search_window)
14079     {
14080       gtk_widget_destroy (tree_view->priv->search_window);
14081
14082       tree_view->priv->search_window = NULL;
14083     }
14084
14085   if (entry)
14086     {
14087       tree_view->priv->search_entry = g_object_ref (entry);
14088       tree_view->priv->search_custom_entry_set = TRUE;
14089
14090       if (tree_view->priv->search_entry_changed_id == 0)
14091         {
14092           tree_view->priv->search_entry_changed_id =
14093             g_signal_connect (tree_view->priv->search_entry, "changed",
14094                               G_CALLBACK (gtk_tree_view_search_init),
14095                               tree_view);
14096         }
14097
14098         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14099                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14100                           tree_view);
14101
14102         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14103     }
14104   else
14105     {
14106       tree_view->priv->search_entry = NULL;
14107       tree_view->priv->search_custom_entry_set = FALSE;
14108     }
14109 }
14110
14111 /**
14112  * gtk_tree_view_set_search_position_func:
14113  * @tree_view: A #GtkTreeView
14114  * @func: the function to use to position the search dialog, or %NULL
14115  *    to use the default search position function
14116  * @data: user data to pass to @func, or %NULL
14117  * @destroy: Destroy notifier for @data, or %NULL
14118  *
14119  * Sets the function to use when positioning the search dialog.
14120  *
14121  * Since: 2.10
14122  **/
14123 void
14124 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
14125                                         GtkTreeViewSearchPositionFunc  func,
14126                                         gpointer                       user_data,
14127                                         GDestroyNotify                 destroy)
14128 {
14129   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14130
14131   if (tree_view->priv->search_position_destroy)
14132     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
14133
14134   tree_view->priv->search_position_func = func;
14135   tree_view->priv->search_position_user_data = user_data;
14136   tree_view->priv->search_position_destroy = destroy;
14137   if (tree_view->priv->search_position_func == NULL)
14138     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
14139 }
14140
14141 /**
14142  * gtk_tree_view_get_search_position_func:
14143  * @tree_view: A #GtkTreeView
14144  *
14145  * Returns the positioning function currently in use.
14146  *
14147  * Return value: the currently used function for positioning the search dialog.
14148  *
14149  * Since: 2.10
14150  */
14151 GtkTreeViewSearchPositionFunc
14152 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
14153 {
14154   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14155
14156   return tree_view->priv->search_position_func;
14157 }
14158
14159
14160 static void
14161 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
14162                                   GtkTreeView *tree_view)
14163 {
14164   if (tree_view->priv->disable_popdown)
14165     return;
14166
14167   if (tree_view->priv->search_entry_changed_id)
14168     {
14169       g_signal_handler_disconnect (tree_view->priv->search_entry,
14170                                    tree_view->priv->search_entry_changed_id);
14171       tree_view->priv->search_entry_changed_id = 0;
14172     }
14173   if (tree_view->priv->typeselect_flush_timeout)
14174     {
14175       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14176       tree_view->priv->typeselect_flush_timeout = 0;
14177     }
14178
14179   if (GTK_WIDGET_VISIBLE (search_dialog))
14180     {
14181       /* send focus-in event */
14182       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), FALSE);
14183       gtk_widget_hide (search_dialog);
14184       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
14185       send_focus_change (GTK_WIDGET (tree_view), TRUE);
14186     }
14187 }
14188
14189 static void
14190 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
14191                                     GtkWidget   *search_dialog,
14192                                     gpointer     user_data)
14193 {
14194   gint x, y;
14195   gint tree_x, tree_y;
14196   gint tree_width, tree_height;
14197   GdkWindow *tree_window = GTK_WIDGET (tree_view)->window;
14198   GdkScreen *screen = gdk_drawable_get_screen (tree_window);
14199   GtkRequisition requisition;
14200   gint monitor_num;
14201   GdkRectangle monitor;
14202
14203   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
14204   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
14205
14206   gtk_widget_realize (search_dialog);
14207
14208   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
14209   gdk_drawable_get_size (tree_window,
14210                          &tree_width,
14211                          &tree_height);
14212   gtk_widget_size_request (search_dialog, &requisition);
14213
14214   if (tree_x + tree_width > gdk_screen_get_width (screen))
14215     x = gdk_screen_get_width (screen) - requisition.width;
14216   else if (tree_x + tree_width - requisition.width < 0)
14217     x = 0;
14218   else
14219     x = tree_x + tree_width - requisition.width;
14220
14221   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
14222     y = gdk_screen_get_height (screen) - requisition.height;
14223   else if (tree_y + tree_height < 0) /* isn't really possible ... */
14224     y = 0;
14225   else
14226     y = tree_y + tree_height;
14227
14228   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
14229 }
14230
14231 static void
14232 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
14233                                       GtkMenu  *menu,
14234                                       gpointer  data)
14235 {
14236   GtkTreeView *tree_view = (GtkTreeView *)data;
14237
14238   tree_view->priv->disable_popdown = 1;
14239   g_signal_connect (menu, "hide",
14240                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
14241 }
14242
14243 /* Because we're visible but offscreen, we just set a flag in the preedit
14244  * callback.
14245  */
14246 static void
14247 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
14248                                       GtkTreeView  *tree_view)
14249 {
14250   tree_view->priv->imcontext_changed = 1;
14251   if (tree_view->priv->typeselect_flush_timeout)
14252     {
14253       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14254       tree_view->priv->typeselect_flush_timeout =
14255         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
14256                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
14257                        tree_view);
14258     }
14259
14260 }
14261
14262 static void
14263 gtk_tree_view_search_activate (GtkEntry    *entry,
14264                                GtkTreeView *tree_view)
14265 {
14266   GtkTreePath *path;
14267   GtkRBNode *node;
14268   GtkRBTree *tree;
14269
14270   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
14271                                     tree_view);
14272
14273   /* If we have a row selected and it's the cursor row, we activate
14274    * the row XXX */
14275   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
14276     {
14277       path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
14278
14279       _gtk_tree_view_find_node (tree_view, path, &tree, &node);
14280
14281       if (node && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
14282         gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
14283
14284       gtk_tree_path_free (path);
14285     }
14286 }
14287
14288 static gboolean
14289 gtk_tree_view_real_search_enable_popdown (gpointer data)
14290 {
14291   GtkTreeView *tree_view = (GtkTreeView *)data;
14292
14293   tree_view->priv->disable_popdown = 0;
14294
14295   return FALSE;
14296 }
14297
14298 static void
14299 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
14300                                      gpointer   data)
14301 {
14302   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
14303 }
14304
14305 static gboolean
14306 gtk_tree_view_search_delete_event (GtkWidget *widget,
14307                                    GdkEventAny *event,
14308                                    GtkTreeView *tree_view)
14309 {
14310   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14311
14312   gtk_tree_view_search_dialog_hide (widget, tree_view);
14313
14314   return TRUE;
14315 }
14316
14317 static gboolean
14318 gtk_tree_view_search_button_press_event (GtkWidget *widget,
14319                                          GdkEventButton *event,
14320                                          GtkTreeView *tree_view)
14321 {
14322   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14323
14324   gtk_tree_view_search_dialog_hide (widget, tree_view);
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_Escape ||
14377           event->keyval == GDK_Tab ||
14378             event->keyval == GDK_KP_Tab ||
14379             event->keyval == GDK_ISO_Left_Tab))
14380     {
14381       gtk_tree_view_search_dialog_hide (widget, tree_view);
14382       return TRUE;
14383     }
14384
14385   /* select previous matching iter */
14386   if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
14387     {
14388       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
14389         gtk_widget_error_bell (widget);
14390
14391       retval = TRUE;
14392     }
14393
14394   if (((event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == (GDK_CONTROL_MASK | GDK_SHIFT_MASK))
14395       && (event->keyval == GDK_g || event->keyval == GDK_G))
14396     {
14397       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
14398         gtk_widget_error_bell (widget);
14399
14400       retval = TRUE;
14401     }
14402
14403   /* select next matching iter */
14404   if (event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
14405     {
14406       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
14407         gtk_widget_error_bell (widget);
14408
14409       retval = TRUE;
14410     }
14411
14412   if (((event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == GDK_CONTROL_MASK)
14413       && (event->keyval == GDK_g || event->keyval == GDK_G))
14414     {
14415       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
14416         gtk_widget_error_bell (widget);
14417
14418       retval = TRUE;
14419     }
14420
14421   /* renew the flush timeout */
14422   if (retval && tree_view->priv->typeselect_flush_timeout
14423       && !tree_view->priv->search_custom_entry_set)
14424     {
14425       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14426       tree_view->priv->typeselect_flush_timeout =
14427         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
14428                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
14429                        tree_view);
14430     }
14431
14432   return retval;
14433 }
14434
14435 /*  this function returns FALSE if there is a search string but
14436  *  nothing was found, and TRUE otherwise.
14437  */
14438 static gboolean
14439 gtk_tree_view_search_move (GtkWidget   *window,
14440                            GtkTreeView *tree_view,
14441                            gboolean     up)
14442 {
14443   gboolean ret;
14444   gint len;
14445   gint count = 0;
14446   const gchar *text;
14447   GtkTreeIter iter;
14448   GtkTreeModel *model;
14449   GtkTreeSelection *selection;
14450
14451   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
14452
14453   g_return_val_if_fail (text != NULL, FALSE);
14454
14455   len = strlen (text);
14456
14457   if (up && tree_view->priv->selected_iter == 1)
14458     return strlen (text) < 1;
14459
14460   len = strlen (text);
14461
14462   if (len < 1)
14463     return TRUE;
14464
14465   model = gtk_tree_view_get_model (tree_view);
14466   selection = gtk_tree_view_get_selection (tree_view);
14467
14468   /* search */
14469   gtk_tree_selection_unselect_all (selection);
14470   if (!gtk_tree_model_get_iter_first (model, &iter))
14471     return TRUE;
14472
14473   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
14474                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
14475
14476   if (ret)
14477     {
14478       /* found */
14479       tree_view->priv->selected_iter += up?(-1):(1);
14480       return TRUE;
14481     }
14482   else
14483     {
14484       /* return to old iter */
14485       count = 0;
14486       gtk_tree_model_get_iter_first (model, &iter);
14487       gtk_tree_view_search_iter (model, selection,
14488                                  &iter, text,
14489                                  &count, tree_view->priv->selected_iter);
14490       return FALSE;
14491     }
14492 }
14493
14494 static gboolean
14495 gtk_tree_view_search_equal_func (GtkTreeModel *model,
14496                                  gint          column,
14497                                  const gchar  *key,
14498                                  GtkTreeIter  *iter,
14499                                  gpointer      search_data)
14500 {
14501   gboolean retval = TRUE;
14502   const gchar *str;
14503   gchar *normalized_string;
14504   gchar *normalized_key;
14505   gchar *case_normalized_string = NULL;
14506   gchar *case_normalized_key = NULL;
14507   GValue value = {0,};
14508   GValue transformed = {0,};
14509
14510   gtk_tree_model_get_value (model, iter, column, &value);
14511
14512   g_value_init (&transformed, G_TYPE_STRING);
14513
14514   if (!g_value_transform (&value, &transformed))
14515     {
14516       g_value_unset (&value);
14517       return TRUE;
14518     }
14519
14520   g_value_unset (&value);
14521
14522   str = g_value_get_string (&transformed);
14523   if (!str)
14524     {
14525       g_value_unset (&transformed);
14526       return TRUE;
14527     }
14528
14529   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
14530   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
14531
14532   if (normalized_string && normalized_key)
14533     {
14534       case_normalized_string = g_utf8_casefold (normalized_string, -1);
14535       case_normalized_key = g_utf8_casefold (normalized_key, -1);
14536
14537       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
14538         retval = FALSE;
14539     }
14540
14541   g_value_unset (&transformed);
14542   g_free (normalized_key);
14543   g_free (normalized_string);
14544   g_free (case_normalized_key);
14545   g_free (case_normalized_string);
14546
14547   return retval;
14548 }
14549
14550 static gboolean
14551 gtk_tree_view_search_iter (GtkTreeModel     *model,
14552                            GtkTreeSelection *selection,
14553                            GtkTreeIter      *iter,
14554                            const gchar      *text,
14555                            gint             *count,
14556                            gint              n)
14557 {
14558   GtkRBTree *tree = NULL;
14559   GtkRBNode *node = NULL;
14560   GtkTreePath *path;
14561
14562   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
14563
14564   path = gtk_tree_model_get_path (model, iter);
14565   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
14566
14567   do
14568     {
14569       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
14570         {
14571           (*count)++;
14572           if (*count == n)
14573             {
14574               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
14575                                             TRUE, 0.5, 0.0);
14576               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
14577               gtk_tree_selection_select_iter (selection, iter);
14578
14579               if (path)
14580                 gtk_tree_path_free (path);
14581
14582               return TRUE;
14583             }
14584         }
14585
14586       if (node->children)
14587         {
14588           gboolean has_child;
14589           GtkTreeIter tmp;
14590
14591           tree = node->children;
14592           node = tree->root;
14593
14594           while (node->left != tree->nil)
14595             node = node->left;
14596
14597           tmp = *iter;
14598           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
14599           gtk_tree_path_down (path);
14600
14601           /* sanity check */
14602           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
14603         }
14604       else
14605         {
14606           gboolean done = FALSE;
14607
14608           do
14609             {
14610               node = _gtk_rbtree_next (tree, node);
14611
14612               if (node)
14613                 {
14614                   gboolean has_next;
14615
14616                   has_next = gtk_tree_model_iter_next (model, iter);
14617
14618                   done = TRUE;
14619                   gtk_tree_path_next (path);
14620
14621                   /* sanity check */
14622                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
14623                 }
14624               else
14625                 {
14626                   gboolean has_parent;
14627                   GtkTreeIter tmp_iter = *iter;
14628
14629                   node = tree->parent_node;
14630                   tree = tree->parent_tree;
14631
14632                   if (!tree)
14633                     {
14634                       if (path)
14635                         gtk_tree_path_free (path);
14636
14637                       /* we've run out of tree, done with this func */
14638                       return FALSE;
14639                     }
14640
14641                   has_parent = gtk_tree_model_iter_parent (model,
14642                                                            iter,
14643                                                            &tmp_iter);
14644                   gtk_tree_path_up (path);
14645
14646                   /* sanity check */
14647                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
14648                 }
14649             }
14650           while (!done);
14651         }
14652     }
14653   while (1);
14654
14655   return FALSE;
14656 }
14657
14658 static void
14659 gtk_tree_view_search_init (GtkWidget   *entry,
14660                            GtkTreeView *tree_view)
14661 {
14662   gint ret;
14663   gint len;
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   len = strlen (text);
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 (len < 1)
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 (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_REALIZED (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_size_request (GTK_WIDGET (cell_editable), &requisition);
14826
14827   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
14828
14829   if (requisition.height < cell_area->height)
14830     {
14831       gint diff = cell_area->height - requisition.height;
14832       gtk_tree_view_put (tree_view,
14833                          GTK_WIDGET (cell_editable),
14834                          cell_area->x, cell_area->y + diff/2,
14835                          cell_area->width, requisition.height);
14836     }
14837   else
14838     {
14839       gtk_tree_view_put (tree_view,
14840                          GTK_WIDGET (cell_editable),
14841                          cell_area->x, cell_area->y,
14842                          cell_area->width, cell_area->height);
14843     }
14844
14845   gtk_cell_editable_start_editing (GTK_CELL_EDITABLE (cell_editable),
14846                                    (GdkEvent *)event);
14847
14848   gtk_widget_grab_focus (GTK_WIDGET (cell_editable));
14849   g_signal_connect (cell_editable, "remove-widget",
14850                     G_CALLBACK (gtk_tree_view_remove_widget), tree_view);
14851 }
14852
14853 static void
14854 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
14855                             gboolean     cancel_editing)
14856 {
14857   GtkTreeViewColumn *column;
14858   GtkCellRenderer *cell;
14859
14860   if (tree_view->priv->edited_column == NULL)
14861     return;
14862
14863   /*
14864    * This is very evil. We need to do this, because
14865    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
14866    * later on. If gtk_tree_view_row_changed notices
14867    * tree_view->priv->edited_column != NULL, it'll call
14868    * gtk_tree_view_stop_editing again. Bad things will happen then.
14869    *
14870    * Please read that again if you intend to modify anything here.
14871    */
14872
14873   column = tree_view->priv->edited_column;
14874   tree_view->priv->edited_column = NULL;
14875
14876   cell = _gtk_tree_view_column_get_edited_cell (column);
14877   gtk_cell_renderer_stop_editing (cell, cancel_editing);
14878
14879   if (!cancel_editing)
14880     gtk_cell_editable_editing_done (column->editable_widget);
14881
14882   tree_view->priv->edited_column = column;
14883
14884   gtk_cell_editable_remove_widget (column->editable_widget);
14885 }
14886
14887
14888 /**
14889  * gtk_tree_view_set_hover_selection:
14890  * @tree_view: a #GtkTreeView
14891  * @hover: %TRUE to enable hover selection mode
14892  *
14893  * Enables of disables the hover selection mode of @tree_view.
14894  * Hover selection makes the selected row follow the pointer.
14895  * Currently, this works only for the selection modes
14896  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
14897  *
14898  * Since: 2.6
14899  **/
14900 void
14901 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
14902                                    gboolean     hover)
14903 {
14904   hover = hover != FALSE;
14905
14906   if (hover != tree_view->priv->hover_selection)
14907     {
14908       tree_view->priv->hover_selection = hover;
14909
14910       g_object_notify (G_OBJECT (tree_view), "hover-selection");
14911     }
14912 }
14913
14914 /**
14915  * gtk_tree_view_get_hover_selection:
14916  * @tree_view: a #GtkTreeView
14917  *
14918  * Returns whether hover selection mode is turned on for @tree_view.
14919  *
14920  * Return value: %TRUE if @tree_view is in hover selection mode
14921  *
14922  * Since: 2.6
14923  **/
14924 gboolean
14925 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
14926 {
14927   return tree_view->priv->hover_selection;
14928 }
14929
14930 /**
14931  * gtk_tree_view_set_hover_expand:
14932  * @tree_view: a #GtkTreeView
14933  * @expand: %TRUE to enable hover selection mode
14934  *
14935  * Enables of disables the hover expansion mode of @tree_view.
14936  * Hover expansion makes rows expand or collapse if the pointer
14937  * moves over them.
14938  *
14939  * Since: 2.6
14940  **/
14941 void
14942 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
14943                                 gboolean     expand)
14944 {
14945   expand = expand != FALSE;
14946
14947   if (expand != tree_view->priv->hover_expand)
14948     {
14949       tree_view->priv->hover_expand = expand;
14950
14951       g_object_notify (G_OBJECT (tree_view), "hover-expand");
14952     }
14953 }
14954
14955 /**
14956  * gtk_tree_view_get_hover_expand:
14957  * @tree_view: a #GtkTreeView
14958  *
14959  * Returns whether hover expansion mode is turned on for @tree_view.
14960  *
14961  * Return value: %TRUE if @tree_view is in hover expansion mode
14962  *
14963  * Since: 2.6
14964  **/
14965 gboolean
14966 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
14967 {
14968   return tree_view->priv->hover_expand;
14969 }
14970
14971 /**
14972  * gtk_tree_view_set_rubber_banding:
14973  * @tree_view: a #GtkTreeView
14974  * @enable: %TRUE to enable rubber banding
14975  *
14976  * Enables or disables rubber banding in @tree_view.  If the selection mode
14977  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
14978  * multiple rows by dragging the mouse.
14979  *
14980  * Since: 2.10
14981  **/
14982 void
14983 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
14984                                   gboolean     enable)
14985 {
14986   enable = enable != FALSE;
14987
14988   if (enable != tree_view->priv->rubber_banding_enable)
14989     {
14990       tree_view->priv->rubber_banding_enable = enable;
14991
14992       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
14993     }
14994 }
14995
14996 /**
14997  * gtk_tree_view_get_rubber_banding:
14998  * @tree_view: a #GtkTreeView
14999  *
15000  * Returns whether rubber banding is turned on for @tree_view.  If the
15001  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15002  * user to select multiple rows by dragging the mouse.
15003  *
15004  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15005  *
15006  * Since: 2.10
15007  **/
15008 gboolean
15009 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15010 {
15011   return tree_view->priv->rubber_banding_enable;
15012 }
15013
15014 /**
15015  * gtk_tree_view_is_rubber_banding_active:
15016  * @tree_view: a #GtkTreeView
15017  *
15018  * Returns whether a rubber banding operation is currently being done
15019  * in @tree_view.
15020  *
15021  * Return value: %TRUE if a rubber banding operation is currently being
15022  * done in @tree_view.
15023  *
15024  * Since: 2.12
15025  **/
15026 gboolean
15027 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15028 {
15029   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15030
15031   if (tree_view->priv->rubber_banding_enable
15032       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15033     return TRUE;
15034
15035   return FALSE;
15036 }
15037
15038 /**
15039  * gtk_tree_view_get_row_separator_func:
15040  * @tree_view: a #GtkTreeView
15041  *
15042  * Returns the current row separator function.
15043  *
15044  * Return value: the current row separator function.
15045  *
15046  * Since: 2.6
15047  **/
15048 GtkTreeViewRowSeparatorFunc
15049 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15050 {
15051   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15052
15053   return tree_view->priv->row_separator_func;
15054 }
15055
15056 /**
15057  * gtk_tree_view_set_row_separator_func:
15058  * @tree_view: a #GtkTreeView
15059  * @func: a #GtkTreeViewRowSeparatorFunc
15060  * @data: user data to pass to @func, or %NULL
15061  * @destroy: destroy notifier for @data, or %NULL
15062  *
15063  * Sets the row separator function, which is used to determine
15064  * whether a row should be drawn as a separator. If the row separator
15065  * function is %NULL, no separators are drawn. This is the default value.
15066  *
15067  * Since: 2.6
15068  **/
15069 void
15070 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15071                                       GtkTreeViewRowSeparatorFunc  func,
15072                                       gpointer                     data,
15073                                       GDestroyNotify               destroy)
15074 {
15075   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15076
15077   if (tree_view->priv->row_separator_destroy)
15078     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15079
15080   tree_view->priv->row_separator_func = func;
15081   tree_view->priv->row_separator_data = data;
15082   tree_view->priv->row_separator_destroy = destroy;
15083 }
15084
15085
15086 static void
15087 gtk_tree_view_grab_notify (GtkWidget *widget,
15088                            gboolean   was_grabbed)
15089 {
15090   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15091
15092   tree_view->priv->in_grab = !was_grabbed;
15093
15094   if (!was_grabbed)
15095     {
15096       tree_view->priv->pressed_button = -1;
15097
15098       if (tree_view->priv->rubber_band_status)
15099         gtk_tree_view_stop_rubber_band (tree_view);
15100     }
15101 }
15102
15103 static void
15104 gtk_tree_view_state_changed (GtkWidget      *widget,
15105                              GtkStateType    previous_state)
15106 {
15107   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15108
15109   if (GTK_WIDGET_REALIZED (widget))
15110     {
15111       gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
15112       gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
15113     }
15114
15115   gtk_widget_queue_draw (widget);
15116 }
15117
15118 /**
15119  * gtk_tree_view_get_grid_lines:
15120  * @tree_view: a #GtkTreeView
15121  *
15122  * Returns which grid lines are enabled in @tree_view.
15123  *
15124  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15125  * are enabled.
15126  *
15127  * Since: 2.10
15128  */
15129 GtkTreeViewGridLines
15130 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15131 {
15132   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15133
15134   return tree_view->priv->grid_lines;
15135 }
15136
15137 /**
15138  * gtk_tree_view_set_grid_lines:
15139  * @tree_view: a #GtkTreeView
15140  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15141  * enable.
15142  *
15143  * Sets which grid lines to draw in @tree_view.
15144  *
15145  * Since: 2.10
15146  */
15147 void
15148 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15149                               GtkTreeViewGridLines   grid_lines)
15150 {
15151   GtkTreeViewPrivate *priv;
15152   GtkWidget *widget;
15153   GtkTreeViewGridLines old_grid_lines;
15154
15155   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15156
15157   priv = tree_view->priv;
15158   widget = GTK_WIDGET (tree_view);
15159
15160   old_grid_lines = priv->grid_lines;
15161   priv->grid_lines = grid_lines;
15162
15163   if (GTK_WIDGET_REALIZED (widget))
15164     {
15165       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15166           priv->grid_line_gc)
15167         {
15168           g_object_unref (priv->grid_line_gc);
15169           priv->grid_line_gc = NULL;
15170         }
15171
15172       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15173           !priv->grid_line_gc)
15174         {
15175           gint line_width;
15176           gint8 *dash_list;
15177
15178           gtk_widget_style_get (widget,
15179                                 "grid-line-width", &line_width,
15180                                 "grid-line-pattern", (gchar *)&dash_list,
15181                                 NULL);
15182
15183           priv->grid_line_gc = gdk_gc_new (widget->window);
15184           gdk_gc_copy (priv->grid_line_gc, widget->style->black_gc);
15185
15186           gdk_gc_set_line_attributes (priv->grid_line_gc, line_width,
15187                                       GDK_LINE_ON_OFF_DASH,
15188                                       GDK_CAP_BUTT, GDK_JOIN_MITER);
15189           gdk_gc_set_dashes (priv->grid_line_gc, 0, dash_list, 2);
15190
15191           g_free (dash_list);
15192         }
15193     }
15194
15195   if (old_grid_lines != grid_lines)
15196     {
15197       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15198
15199       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
15200     }
15201 }
15202
15203 /**
15204  * gtk_tree_view_get_enable_tree_lines:
15205  * @tree_view: a #GtkTreeView.
15206  *
15207  * Returns whether or not tree lines are drawn in @tree_view.
15208  *
15209  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
15210  * otherwise.
15211  *
15212  * Since: 2.10
15213  */
15214 gboolean
15215 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
15216 {
15217   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15218
15219   return tree_view->priv->tree_lines_enabled;
15220 }
15221
15222 /**
15223  * gtk_tree_view_set_enable_tree_lines:
15224  * @tree_view: a #GtkTreeView
15225  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
15226  *
15227  * Sets whether to draw lines interconnecting the expanders in @tree_view.
15228  * This does not have any visible effects for lists.
15229  *
15230  * Since: 2.10
15231  */
15232 void
15233 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
15234                                      gboolean     enabled)
15235 {
15236   GtkTreeViewPrivate *priv;
15237   GtkWidget *widget;
15238   gboolean was_enabled;
15239
15240   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15241
15242   enabled = enabled != FALSE;
15243
15244   priv = tree_view->priv;
15245   widget = GTK_WIDGET (tree_view);
15246
15247   was_enabled = priv->tree_lines_enabled;
15248
15249   priv->tree_lines_enabled = enabled;
15250
15251   if (GTK_WIDGET_REALIZED (widget))
15252     {
15253       if (!enabled && priv->tree_line_gc)
15254         {
15255           g_object_unref (priv->tree_line_gc);
15256           priv->tree_line_gc = NULL;
15257         }
15258
15259       if (enabled && !priv->tree_line_gc)
15260         {
15261           gint line_width;
15262           gint8 *dash_list;
15263           gtk_widget_style_get (widget,
15264                                 "tree-line-width", &line_width,
15265                                 "tree-line-pattern", (gchar *)&dash_list,
15266                                 NULL);
15267
15268           priv->tree_line_gc = gdk_gc_new (widget->window);
15269           gdk_gc_copy (priv->tree_line_gc, widget->style->black_gc);
15270
15271           gdk_gc_set_line_attributes (priv->tree_line_gc, line_width,
15272                                       GDK_LINE_ON_OFF_DASH,
15273                                       GDK_CAP_BUTT, GDK_JOIN_MITER);
15274           gdk_gc_set_dashes (priv->tree_line_gc, 0, dash_list, 2);
15275
15276           g_free (dash_list);
15277         }
15278     }
15279
15280   if (was_enabled != enabled)
15281     {
15282       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15283
15284       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
15285     }
15286 }
15287
15288
15289 /**
15290  * gtk_tree_view_set_show_expanders:
15291  * @tree_view: a #GtkTreeView
15292  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
15293  *
15294  * Sets whether to draw and enable expanders and indent child rows in
15295  * @tree_view.  When disabled there will be no expanders visible in trees
15296  * and there will be no way to expand and collapse rows by default.  Also
15297  * note that hiding the expanders will disable the default indentation.  You
15298  * can set a custom indentation in this case using
15299  * gtk_tree_view_set_level_indentation().
15300  * This does not have any visible effects for lists.
15301  *
15302  * Since: 2.12
15303  */
15304 void
15305 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
15306                                   gboolean     enabled)
15307 {
15308   gboolean was_enabled;
15309
15310   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15311
15312   enabled = enabled != FALSE;
15313   was_enabled = GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15314
15315   if (enabled)
15316     GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15317   else
15318     GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15319
15320   if (enabled != was_enabled)
15321     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15322 }
15323
15324 /**
15325  * gtk_tree_view_get_show_expanders:
15326  * @tree_view: a #GtkTreeView.
15327  *
15328  * Returns whether or not expanders are drawn in @tree_view.
15329  *
15330  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
15331  * otherwise.
15332  *
15333  * Since: 2.12
15334  */
15335 gboolean
15336 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
15337 {
15338   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15339
15340   return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15341 }
15342
15343 /**
15344  * gtk_tree_view_set_level_indentation:
15345  * @tree_view: a #GtkTreeView
15346  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
15347  *
15348  * Sets the amount of extra indentation for child levels to use in @tree_view
15349  * in addition to the default indentation.  The value should be specified in
15350  * pixels, a value of 0 disables this feature and in this case only the default
15351  * indentation will be used.
15352  * This does not have any visible effects for lists.
15353  *
15354  * Since: 2.12
15355  */
15356 void
15357 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
15358                                      gint         indentation)
15359 {
15360   tree_view->priv->level_indentation = indentation;
15361
15362   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15363 }
15364
15365 /**
15366  * gtk_tree_view_get_level_indentation:
15367  * @tree_view: a #GtkTreeView.
15368  *
15369  * Returns the amount, in pixels, of extra indentation for child levels
15370  * in @tree_view.
15371  *
15372  * Return value: the amount of extra indentation for child levels in
15373  * @tree_view.  A return value of 0 means that this feature is disabled.
15374  *
15375  * Since: 2.12
15376  */
15377 gint
15378 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
15379 {
15380   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15381
15382   return tree_view->priv->level_indentation;
15383 }
15384
15385 /**
15386  * gtk_tree_view_set_tooltip_row:
15387  * @tree_view: a #GtkTreeView
15388  * @tooltip: a #GtkTooltip
15389  * @path: a #GtkTreePath
15390  *
15391  * Sets the tip area of @tooltip to be the area covered by the row at @path.
15392  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
15393  * See also gtk_tooltip_set_tip_area().
15394  *
15395  * Since: 2.12
15396  */
15397 void
15398 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
15399                                GtkTooltip  *tooltip,
15400                                GtkTreePath *path)
15401 {
15402   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15403   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
15404
15405   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
15406 }
15407
15408 /**
15409  * gtk_tree_view_set_tooltip_cell:
15410  * @tree_view: a #GtkTreeView
15411  * @tooltip: a #GtkTooltip
15412  * @path: a #GtkTreePath or %NULL
15413  * @column: a #GtkTreeViewColumn or %NULL
15414  * @cell: a #GtkCellRenderer or %NULL
15415  *
15416  * Sets the tip area of @tooltip to the area @path, @column and @cell have
15417  * in common.  For example if @path is %NULL and @column is set, the tip
15418  * area will be set to the full area covered by @column.  See also
15419  * gtk_tooltip_set_tip_area().
15420  *
15421  * Note that if @path is not specified and @cell is set and part of a column
15422  * containing the expander, the tooltip might not show and hide at the correct
15423  * position.  In such cases @path must be set to the current node under the
15424  * mouse cursor for this function to operate correctly.
15425  *
15426  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
15427  *
15428  * Since: 2.12
15429  */
15430 void
15431 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
15432                                 GtkTooltip        *tooltip,
15433                                 GtkTreePath       *path,
15434                                 GtkTreeViewColumn *column,
15435                                 GtkCellRenderer   *cell)
15436 {
15437   GdkRectangle rect;
15438
15439   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15440   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
15441
15442   if (column)
15443     g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
15444
15445   if (cell)
15446     g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
15447
15448   /* Determine x values. */
15449   if (column && cell)
15450     {
15451       GdkRectangle tmp;
15452       gint start, width;
15453
15454       /* We always pass in path here, whether it is NULL or not.
15455        * For cells in expander columns path must be specified so that
15456        * we can correctly account for the indentation.  This also means
15457        * that the tooltip is constrained vertically by the "Determine y
15458        * values" code below; this is not a real problem since cells actually
15459        * don't stretch vertically in constrast to columns.
15460        */
15461       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
15462       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
15463
15464       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
15465                                                          tmp.x + start, 0,
15466                                                          &rect.x, NULL);
15467       rect.width = width;
15468     }
15469   else if (column)
15470     {
15471       GdkRectangle tmp;
15472
15473       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
15474       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
15475                                                          tmp.x, 0,
15476                                                          &rect.x, NULL);
15477       rect.width = tmp.width;
15478     }
15479   else
15480     {
15481       rect.x = 0;
15482       rect.width = GTK_WIDGET (tree_view)->allocation.width;
15483     }
15484
15485   /* Determine y values. */
15486   if (path)
15487     {
15488       GdkRectangle tmp;
15489
15490       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
15491       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
15492                                                          0, tmp.y,
15493                                                          NULL, &rect.y);
15494       rect.height = tmp.height;
15495     }
15496   else
15497     {
15498       rect.y = 0;
15499       rect.height = tree_view->priv->vadjustment->page_size;
15500     }
15501
15502   gtk_tooltip_set_tip_area (tooltip, &rect);
15503 }
15504
15505 /**
15506  * gtk_tree_view_get_tooltip_context:
15507  * @tree_view: a #GtkTreeView
15508  * @x: the x coordinate (relative to widget coordinates)
15509  * @y: the y coordinate (relative to widget coordinates)
15510  * @keyboard_tip: whether this is a keyboard tooltip or not
15511  * @model: a pointer to receive a #GtkTreeModel or %NULL
15512  * @path: a pointer to receive a #GtkTreePath or %NULL
15513  * @iter: a pointer to receive a #GtkTreeIter or %NULL
15514  *
15515  * This function is supposed to be used in a #GtkWidget::query-tooltip
15516  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
15517  * which are received in the signal handler, should be passed to this
15518  * function without modification.
15519  *
15520  * The return value indicates whether there is a tree view row at the given
15521  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
15522  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
15523  * @model, @path and @iter which have been provided will be set to point to
15524  * that row and the corresponding model.  @x and @y will always be converted
15525  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
15526  *
15527  * Return value: whether or not the given tooltip context points to a row.
15528  *
15529  * Since: 2.12
15530  */
15531 gboolean
15532 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
15533                                    gint          *x,
15534                                    gint          *y,
15535                                    gboolean       keyboard_tip,
15536                                    GtkTreeModel **model,
15537                                    GtkTreePath  **path,
15538                                    GtkTreeIter   *iter)
15539 {
15540   GtkTreePath *tmppath = NULL;
15541
15542   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15543   g_return_val_if_fail (x != NULL, FALSE);
15544   g_return_val_if_fail (y != NULL, FALSE);
15545
15546   if (keyboard_tip)
15547     {
15548       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
15549
15550       if (!tmppath)
15551         return FALSE;
15552     }
15553   else
15554     {
15555       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
15556                                                          x, y);
15557
15558       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
15559                                           &tmppath, NULL, NULL, NULL))
15560         return FALSE;
15561     }
15562
15563   if (model)
15564     *model = gtk_tree_view_get_model (tree_view);
15565
15566   if (iter)
15567     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
15568                              iter, tmppath);
15569
15570   if (path)
15571     *path = tmppath;
15572   else
15573     gtk_tree_path_free (tmppath);
15574
15575   return TRUE;
15576 }
15577
15578 static gboolean
15579 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
15580                                     gint        x,
15581                                     gint        y,
15582                                     gboolean    keyboard_tip,
15583                                     GtkTooltip *tooltip,
15584                                     gpointer    data)
15585 {
15586   GValue value = { 0, };
15587   GValue transformed = { 0, };
15588   GtkTreeIter iter;
15589   GtkTreePath *path;
15590   GtkTreeModel *model;
15591   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15592
15593   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
15594                                           &x, &y,
15595                                           keyboard_tip,
15596                                           &model, &path, &iter))
15597     return FALSE;
15598
15599   gtk_tree_model_get_value (model, &iter,
15600                             tree_view->priv->tooltip_column, &value);
15601
15602   g_value_init (&transformed, G_TYPE_STRING);
15603
15604   if (!g_value_transform (&value, &transformed))
15605     {
15606       g_value_unset (&value);
15607       gtk_tree_path_free (path);
15608
15609       return FALSE;
15610     }
15611
15612   g_value_unset (&value);
15613
15614   if (!g_value_get_string (&transformed))
15615     {
15616       g_value_unset (&transformed);
15617       gtk_tree_path_free (path);
15618
15619       return FALSE;
15620     }
15621
15622   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
15623   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
15624
15625   gtk_tree_path_free (path);
15626   g_value_unset (&transformed);
15627
15628   return TRUE;
15629 }
15630
15631 /**
15632  * gtk_tree_view_set_tooltip_column:
15633  * @tree_view: a #GtkTreeView
15634  * @column: an integer, which is a valid column number for @tree_view's model
15635  *
15636  * If you only plan to have simple (text-only) tooltips on full rows, you
15637  * can use this function to have #GtkTreeView handle these automatically
15638  * for you. @column should be set to the column in @tree_view's model
15639  * containing the tooltip texts, or -1 to disable this feature.
15640  *
15641  * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
15642  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
15643  *
15644  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
15645  * so &amp;, &lt;, etc have to be escaped in the text.
15646  *
15647  * Since: 2.12
15648  */
15649 void
15650 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
15651                                   gint         column)
15652 {
15653   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15654
15655   if (column == tree_view->priv->tooltip_column)
15656     return;
15657
15658   if (column == -1)
15659     {
15660       g_signal_handlers_disconnect_by_func (tree_view,
15661                                             gtk_tree_view_set_tooltip_query_cb,
15662                                             NULL);
15663       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
15664     }
15665   else
15666     {
15667       if (tree_view->priv->tooltip_column == -1)
15668         {
15669           g_signal_connect (tree_view, "query-tooltip",
15670                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
15671           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
15672         }
15673     }
15674
15675   tree_view->priv->tooltip_column = column;
15676   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
15677 }
15678
15679 /**
15680  * gtk_tree_view_get_tooltip_column:
15681  * @tree_view: a #GtkTreeView
15682  *
15683  * Returns the column of @tree_view's model which is being used for
15684  * displaying tooltips on @tree_view's rows.
15685  *
15686  * Return value: the index of the tooltip column that is currently being
15687  * used, or -1 if this is disabled.
15688  *
15689  * Since: 2.12
15690  */
15691 gint
15692 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
15693 {
15694   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15695
15696   return tree_view->priv->tooltip_column;
15697 }
15698
15699 #define __GTK_TREE_VIEW_C__
15700 #include "gtkaliasdef.c"