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