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

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