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