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