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

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