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

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