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

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