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_user_data)
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       ! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
4267     {
4268       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
4269       tree_view->priv->scroll_to_path = NULL;
4270     }
4271
4272   if (above_path)
4273     gtk_tree_path_free (above_path);
4274
4275   if (tree_view->priv->scroll_to_column)
4276     {
4277       tree_view->priv->scroll_to_column = NULL;
4278     }
4279   if (need_redraw)
4280     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4281 }
4282
4283
4284 /* Our strategy for finding nodes to validate is a little convoluted.  We find
4285  * the left-most uninvalidated node.  We then try walking right, validating
4286  * nodes.  Once we find a valid node, we repeat the previous process of finding
4287  * the first invalid node.
4288  */
4289
4290 static gboolean
4291 do_validate_rows (GtkTreeView *tree_view)
4292 {
4293   GtkRBTree *tree = NULL;
4294   GtkRBNode *node = NULL;
4295   gboolean validated_area = FALSE;
4296   gint retval = TRUE;
4297   GtkTreePath *path = NULL;
4298   GtkTreeIter iter;
4299   gint i = 0;
4300
4301   gint prev_height = -1;
4302   gboolean fixed_height = TRUE;
4303
4304   g_assert (tree_view);
4305
4306   if (tree_view->priv->tree == NULL)
4307       return FALSE;
4308
4309   do
4310     {
4311       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
4312         {
4313           retval = FALSE;
4314           goto done;
4315         }
4316
4317       if (path != NULL)
4318         {
4319           node = _gtk_rbtree_next (tree, node);
4320           if (node != NULL)
4321             {
4322               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
4323               gtk_tree_path_next (path);
4324             }
4325           else
4326             {
4327               gtk_tree_path_free (path);
4328               path = NULL;
4329             }
4330         }
4331
4332       if (path == NULL)
4333         {
4334           tree = tree_view->priv->tree;
4335           node = tree_view->priv->tree->root;
4336
4337           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
4338
4339           do
4340             {
4341               if (node->left != tree->nil &&
4342                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
4343                 {
4344                   node = node->left;
4345                 }
4346               else if (node->right != tree->nil &&
4347                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
4348                 {
4349                   node = node->right;
4350                 }
4351               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
4352                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
4353                 {
4354                   break;
4355                 }
4356               else if (node->children != NULL)
4357                 {
4358                   tree = node->children;
4359                   node = tree->root;
4360                 }
4361               else
4362                 /* RBTree corruption!  All bad */
4363                 g_assert_not_reached ();
4364             }
4365           while (TRUE);
4366           path = _gtk_tree_view_find_path (tree_view, tree, node);
4367           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
4368         }
4369       validated_area = validate_row (tree_view, tree, node, &iter, path) | validated_area;
4370
4371       if (!tree_view->priv->fixed_height_check)
4372         {
4373           gint height;
4374
4375           height = MAX (GTK_RBNODE_GET_HEIGHT (node), tree_view->priv->expander_size);
4376           if (prev_height < 0)
4377             prev_height = height;
4378           else if (prev_height != height)
4379             fixed_height = FALSE;
4380         }
4381
4382       i++;
4383     }
4384   while (i < GTK_TREE_VIEW_NUM_ROWS_PER_IDLE);
4385
4386   if (!tree_view->priv->fixed_height_check)
4387    {
4388      if (fixed_height)
4389        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height);
4390
4391      tree_view->priv->fixed_height_check = 1;
4392    }
4393
4394  done:
4395   if (validated_area)
4396     {
4397       GtkRequisition requisition;
4398       /* We temporarily guess a size, under the assumption that it will be the
4399        * same when we get our next size_allocate.  If we don't do this, we'll be
4400        * in an inconsistent state when we call top_row_to_dy. */
4401       gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
4402       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
4403       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
4404       gtk_adjustment_changed (tree_view->priv->hadjustment);
4405       gtk_adjustment_changed (tree_view->priv->vadjustment);
4406       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
4407     }
4408
4409   if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
4410     gtk_tree_view_top_row_to_dy (tree_view);
4411   else
4412     gtk_tree_view_dy_to_top_row (tree_view);
4413
4414   if (path) gtk_tree_path_free (path);
4415
4416   return retval;
4417 }
4418
4419 static gboolean
4420 validate_rows (GtkTreeView *tree_view)
4421 {
4422   gboolean retval;
4423
4424   retval = do_validate_rows (tree_view);
4425
4426   if (! retval && tree_view->priv->validate_rows_timer)
4427     {
4428       g_source_remove (tree_view->priv->validate_rows_timer);
4429       tree_view->priv->validate_rows_timer = 0;
4430     }
4431
4432   return retval;
4433 }
4434
4435 static gboolean
4436 validate_rows_handler (GtkTreeView *tree_view)
4437 {
4438   gboolean retval;
4439
4440   GDK_THREADS_ENTER ();
4441
4442   retval = do_validate_rows (tree_view);
4443   if (! retval)
4444     tree_view->priv->validate_rows_timer = 0;
4445
4446   GDK_THREADS_LEAVE ();
4447
4448   return retval;
4449 }
4450
4451 static gboolean
4452 do_presize_handler (GtkTreeView *tree_view)
4453 {
4454   if (tree_view->priv->mark_rows_col_dirty)
4455     {
4456       if (tree_view->priv->tree)
4457         _gtk_rbtree_column_invalid (tree_view->priv->tree);
4458       tree_view->priv->mark_rows_col_dirty = FALSE;
4459     }
4460   validate_visible_area (tree_view);
4461   tree_view->priv->presize_handler_timer = 0;
4462
4463   return FALSE;
4464 }
4465
4466 static gboolean
4467 presize_handler_callback (gpointer data)
4468 {
4469   GDK_THREADS_ENTER ();
4470
4471   do_presize_handler (GTK_TREE_VIEW (data));
4472
4473   GDK_THREADS_LEAVE ();
4474
4475   return FALSE;
4476 }
4477
4478 static void
4479 install_presize_handler (GtkTreeView *tree_view)
4480 {
4481   if (! GTK_WIDGET_REALIZED (tree_view))
4482     return;
4483
4484   if (! tree_view->priv->presize_handler_timer)
4485     {
4486       tree_view->priv->presize_handler_timer =
4487         g_idle_add_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
4488     }
4489   if (! tree_view->priv->validate_rows_timer)
4490     {
4491       tree_view->priv->validate_rows_timer =
4492         g_idle_add_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
4493     }
4494 }
4495
4496 static gboolean
4497 scroll_sync_handler (GtkTreeView *tree_view)
4498 {
4499
4500   GDK_THREADS_ENTER ();
4501
4502   if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
4503     gtk_tree_view_top_row_to_dy (tree_view);
4504   else
4505     gtk_tree_view_dy_to_top_row (tree_view);
4506
4507   tree_view->priv->scroll_sync_timer = 0;
4508
4509   GDK_THREADS_LEAVE ();
4510
4511   return FALSE;
4512 }
4513
4514 static void
4515 install_scroll_sync_handler (GtkTreeView *tree_view)
4516 {
4517   if (! GTK_WIDGET_REALIZED (tree_view))
4518     return;
4519
4520   if (!tree_view->priv->scroll_sync_timer)
4521     {
4522       tree_view->priv->scroll_sync_timer =
4523         g_idle_add_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
4524     }
4525 }
4526
4527 /* Always call this iff dy is in the visible range.  If the tree is empty, then
4528  * it's set to be NULL, and top_row_dy is 0;
4529  */
4530 static void
4531 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
4532 {
4533   GtkTreePath *path;
4534   GtkRBTree *tree;
4535   GtkRBNode *node;
4536
4537   gtk_tree_row_reference_free (tree_view->priv->top_row);
4538   if (tree_view->priv->tree == NULL)
4539     tree = NULL;
4540   else
4541     tree_view->priv->top_row_dy = _gtk_rbtree_find_offset (tree_view->priv->tree,
4542                                                            tree_view->priv->dy,
4543                                                            &tree, &node);
4544   if (tree == NULL)
4545     {
4546       tree_view->priv->top_row = NULL;
4547       tree_view->priv->top_row_dy = 0;
4548       return;
4549     }
4550
4551   path = _gtk_tree_view_find_path (tree_view, tree, node);
4552   tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
4553   gtk_tree_path_free (path);
4554 }
4555
4556 static void
4557 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
4558 {
4559   GtkTreePath *path;
4560   GtkRBTree *tree;
4561   GtkRBNode *node;
4562
4563   if (tree_view->priv->top_row)
4564     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
4565   else
4566     path = NULL;
4567
4568   if (!path)
4569     tree = NULL;
4570   else
4571     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
4572
4573   if (path)
4574     gtk_tree_path_free (path);
4575
4576   if (tree == NULL)
4577     {
4578       /* keep dy and set new toprow */
4579       gtk_tree_row_reference_free (tree_view->priv->top_row);
4580       tree_view->priv->top_row = NULL;
4581       tree_view->priv->top_row_dy = 0;
4582       /* DO NOT install the idle handler */
4583       gtk_tree_view_dy_to_top_row (tree_view);
4584       return;
4585     }
4586
4587   if (MAX (BACKGROUND_HEIGHT (node), tree_view->priv->expander_size)
4588       < tree_view->priv->top_row_dy)
4589     {
4590       /* new top row -- do NOT install the idle handler */
4591       gtk_tree_view_dy_to_top_row (tree_view);
4592       return;
4593     }
4594
4595   tree_view->priv->dy = _gtk_rbtree_node_find_offset (tree, node);
4596   tree_view->priv->dy += tree_view->priv->top_row_dy;
4597   gtk_adjustment_set_value (tree_view->priv->vadjustment,
4598                             (gdouble)tree_view->priv->dy);
4599 }
4600
4601
4602 void
4603 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view)
4604 {
4605   tree_view->priv->mark_rows_col_dirty = TRUE;
4606
4607   install_presize_handler (tree_view);
4608 }
4609
4610 /*
4611  * This function works synchronously (due to the while (validate_rows...)
4612  * loop).
4613  *
4614  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
4615  * here. You now need to check that yourself.
4616  */
4617 void
4618 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
4619                                 GtkTreeViewColumn *column)
4620 {
4621   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
4622   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
4623
4624   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
4625
4626   do_presize_handler (tree_view);
4627   while (validate_rows (tree_view));
4628
4629   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
4630 }
4631
4632 /* Drag-and-drop */
4633
4634 static void
4635 set_source_row (GdkDragContext *context,
4636                 GtkTreeModel   *model,
4637                 GtkTreePath    *source_row)
4638 {
4639   g_object_set_data_full (G_OBJECT (context),
4640                           "gtk-tree-view-source-row",
4641                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
4642                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
4643 }
4644
4645 static GtkTreePath*
4646 get_source_row (GdkDragContext *context)
4647 {
4648   GtkTreeRowReference *ref =
4649     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
4650
4651   if (ref)
4652     return gtk_tree_row_reference_get_path (ref);
4653   else
4654     return NULL;
4655 }
4656
4657
4658 static void
4659 set_dest_row (GdkDragContext *context,
4660               GtkTreeModel   *model,
4661               GtkTreePath    *dest_row)
4662 {
4663   g_object_set_data_full (G_OBJECT (context),
4664                           "gtk-tree-view-dest-row",
4665                           dest_row ? gtk_tree_row_reference_new (model, dest_row) : NULL,
4666                           (GDestroyNotify) (dest_row ? gtk_tree_row_reference_free : NULL));
4667 }
4668
4669 static GtkTreePath*
4670 get_dest_row (GdkDragContext *context)
4671 {
4672   GtkTreeRowReference *ref =
4673     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
4674
4675   if (ref)
4676     return gtk_tree_row_reference_get_path (ref);
4677   else
4678     return NULL;
4679 }
4680
4681 /* Get/set whether drag_motion requested the drag data and
4682  * drag_data_received should thus not actually insert the data,
4683  * since the data doesn't result from a drop.
4684  */
4685 static void
4686 set_status_pending (GdkDragContext *context,
4687                     GdkDragAction   suggested_action)
4688 {
4689   g_object_set_data (G_OBJECT (context),
4690                      "gtk-tree-view-status-pending",
4691                      GINT_TO_POINTER (suggested_action));
4692 }
4693
4694 static GdkDragAction
4695 get_status_pending (GdkDragContext *context)
4696 {
4697   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
4698                                              "gtk-tree-view-status-pending"));
4699 }
4700
4701 static TreeViewDragInfo*
4702 get_info (GtkTreeView *tree_view)
4703 {
4704   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
4705 }
4706
4707 static void
4708 clear_source_info (TreeViewDragInfo *di)
4709 {
4710   if (di->source_target_list)
4711     gtk_target_list_unref (di->source_target_list);
4712
4713   di->source_target_list = NULL;
4714 }
4715
4716 static void
4717 clear_dest_info (TreeViewDragInfo *di)
4718 {
4719   if (di->dest_target_list)
4720     gtk_target_list_unref (di->dest_target_list);
4721
4722   di->dest_target_list = NULL;
4723 }
4724
4725 static void
4726 destroy_info (TreeViewDragInfo *di)
4727 {
4728   clear_source_info (di);
4729   clear_dest_info (di);
4730   g_free (di);
4731 }
4732
4733 static TreeViewDragInfo*
4734 ensure_info (GtkTreeView *tree_view)
4735 {
4736   TreeViewDragInfo *di;
4737
4738   di = get_info (tree_view);
4739
4740   if (di == NULL)
4741     {
4742       di = g_new0 (TreeViewDragInfo, 1);
4743
4744       g_object_set_data_full (G_OBJECT (tree_view),
4745                               "gtk-tree-view-drag-info",
4746                               di,
4747                               (GDestroyNotify) destroy_info);
4748     }
4749
4750   return di;
4751 }
4752
4753 static void
4754 remove_info (GtkTreeView *tree_view)
4755 {
4756   g_object_set_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info", NULL);
4757 }
4758
4759 #if 0
4760 static gint
4761 drag_scan_timeout (gpointer data)
4762 {
4763   GtkTreeView *tree_view;
4764   gint x, y;
4765   GdkModifierType state;
4766   GtkTreePath *path = NULL;
4767   GtkTreeViewColumn *column = NULL;
4768   GdkRectangle visible_rect;
4769
4770   GDK_THREADS_ENTER ();
4771
4772   tree_view = GTK_TREE_VIEW (data);
4773
4774   gdk_window_get_pointer (tree_view->priv->bin_window,
4775                           &x, &y, &state);
4776
4777   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4778
4779   /* See if we are near the edge. */
4780   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
4781       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
4782       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
4783       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
4784     {
4785       gtk_tree_view_get_path_at_pos (tree_view,
4786                                      tree_view->priv->bin_window,
4787                                      x, y,
4788                                      &path,
4789                                      &column,
4790                                      NULL,
4791                                      NULL);
4792
4793       if (path != NULL)
4794         {
4795           gtk_tree_view_scroll_to_cell (tree_view,
4796                                         path,
4797                                         column,
4798                                         TRUE,
4799                                         0.5, 0.5);
4800
4801           gtk_tree_path_free (path);
4802         }
4803     }
4804
4805   GDK_THREADS_LEAVE ();
4806
4807   return TRUE;
4808 }
4809 #endif /* 0 */
4810
4811 static void
4812 remove_scroll_timeout (GtkTreeView *tree_view)
4813 {
4814   if (tree_view->priv->scroll_timeout != 0)
4815     {
4816       g_source_remove (tree_view->priv->scroll_timeout);
4817       tree_view->priv->scroll_timeout = 0;
4818     }
4819 }
4820 static gboolean
4821 check_model_dnd (GtkTreeModel *model,
4822                  GType         required_iface,
4823                  const gchar  *signal)
4824 {
4825   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
4826     {
4827       g_warning ("You must override the default '%s' handler "
4828                  "on GtkTreeView when using models that don't support "
4829                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
4830                  "is to connect to '%s' and call "
4831                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
4832                  "the default handler from running. Look at the source code "
4833                  "for the default handler in gtktreeview.c to get an idea what "
4834                  "your handler should do. (gtktreeview.c is in the GTK source "
4835                  "code.) If you're using GTK from a language other than C, "
4836                  "there may be a more natural way to override default handlers, e.g. via derivation.",
4837                  signal, g_type_name (required_iface), signal);
4838       return FALSE;
4839     }
4840   else
4841     return TRUE;
4842 }
4843
4844 static void
4845 remove_open_timeout (GtkTreeView *tree_view)
4846 {
4847   if (tree_view->priv->open_dest_timeout != 0)
4848     {
4849       g_source_remove (tree_view->priv->open_dest_timeout);
4850       tree_view->priv->open_dest_timeout = 0;
4851     }
4852 }
4853
4854
4855 static gint
4856 open_row_timeout (gpointer data)
4857 {
4858   GtkTreeView *tree_view = data;
4859   GtkTreePath *dest_path = NULL;
4860   GtkTreeViewDropPosition pos;
4861   gboolean result = FALSE;
4862
4863   GDK_THREADS_ENTER ();
4864
4865   gtk_tree_view_get_drag_dest_row (tree_view,
4866                                    &dest_path,
4867                                    &pos);
4868
4869   if (dest_path &&
4870       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
4871        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
4872     {
4873       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
4874       tree_view->priv->open_dest_timeout = 0;
4875
4876       gtk_tree_path_free (dest_path);
4877     }
4878   else
4879     {
4880       if (dest_path)
4881         gtk_tree_path_free (dest_path);
4882
4883       result = TRUE;
4884     }
4885
4886   GDK_THREADS_LEAVE ();
4887
4888   return result;
4889 }
4890
4891 static gint
4892 scroll_row_timeout (gpointer data)
4893 {
4894   GtkTreeView *tree_view = data;
4895
4896   GDK_THREADS_ENTER ();
4897
4898   gtk_tree_view_vertical_autoscroll (tree_view);
4899
4900   GDK_THREADS_LEAVE ();
4901
4902   return TRUE;
4903 }
4904
4905 /* Returns TRUE if event should not be propagated to parent widgets */
4906 static gboolean
4907 set_destination_row (GtkTreeView    *tree_view,
4908                      GdkDragContext *context,
4909                      gint            x,
4910                      gint            y,
4911                      GdkDragAction  *suggested_action,
4912                      GdkAtom        *target)
4913 {
4914   GtkTreePath *path = NULL;
4915   GtkTreeViewDropPosition pos;
4916   GtkTreeViewDropPosition old_pos;
4917   TreeViewDragInfo *di;
4918   GtkWidget *widget;
4919   GtkTreePath *old_dest_path = NULL;
4920
4921   *suggested_action = 0;
4922   *target = GDK_NONE;
4923
4924   widget = GTK_WIDGET (tree_view);
4925
4926   di = get_info (tree_view);
4927
4928   if (di == NULL)
4929     {
4930       /* someone unset us as a drag dest, note that if
4931        * we return FALSE drag_leave isn't called
4932        */
4933
4934       gtk_tree_view_set_drag_dest_row (tree_view,
4935                                        NULL,
4936                                        GTK_TREE_VIEW_DROP_BEFORE);
4937
4938       remove_scroll_timeout (GTK_TREE_VIEW (widget));
4939       remove_open_timeout (GTK_TREE_VIEW (widget));
4940
4941       return FALSE; /* no longer a drop site */
4942     }
4943
4944   *target = gtk_drag_dest_find_target (widget, context, di->dest_target_list);
4945   if (*target == GDK_NONE)
4946     {
4947       return FALSE;
4948     }
4949
4950   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
4951                                           x, y,
4952                                           &path,
4953                                           &pos))
4954     {
4955       /* can't drop here */
4956       remove_open_timeout (tree_view);
4957
4958       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
4959                                        NULL,
4960                                        GTK_TREE_VIEW_DROP_BEFORE);
4961
4962       if (path)
4963         gtk_tree_path_free (path);
4964
4965       /* don't propagate to parent though */
4966       return TRUE;
4967     }
4968
4969   g_assert (path);
4970
4971   /* If we left the current row's "open" zone, unset the timeout for
4972    * opening the row
4973    */
4974   gtk_tree_view_get_drag_dest_row (tree_view,
4975                                    &old_dest_path,
4976                                    &old_pos);
4977
4978   if (old_dest_path &&
4979       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
4980        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
4981          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
4982     remove_open_timeout (tree_view);
4983
4984   if (old_dest_path)
4985     gtk_tree_path_free (old_dest_path);
4986
4987   if (TRUE /* FIXME if the location droppable predicate */)
4988     {
4989       GtkWidget *source_widget;
4990
4991       *suggested_action = context->suggested_action;
4992
4993       source_widget = gtk_drag_get_source_widget (context);
4994
4995       if (source_widget == widget)
4996         {
4997           /* Default to MOVE, unless the user has
4998            * pressed ctrl or alt to affect available actions
4999            */
5000           if ((context->actions & GDK_ACTION_MOVE) != 0)
5001             *suggested_action = GDK_ACTION_MOVE;
5002         }
5003
5004       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
5005                                        path, pos);
5006     }
5007   else
5008     {
5009       /* can't drop here */
5010       remove_open_timeout (tree_view);
5011
5012       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
5013                                        NULL,
5014                                        GTK_TREE_VIEW_DROP_BEFORE);
5015     }
5016
5017   if (path)
5018     gtk_tree_path_free (path);
5019
5020   return TRUE;
5021 }
5022 static GtkTreePath*
5023 get_logical_dest_row (GtkTreeView *tree_view)
5024
5025 {
5026   /* adjust path to point to the row the drop goes in front of */
5027   GtkTreePath *path = NULL;
5028   GtkTreeViewDropPosition pos;
5029
5030   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
5031
5032   if (path == NULL)
5033     return NULL;
5034
5035   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
5036     ; /* do nothing */
5037   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
5038            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
5039     {
5040       /* get first child, drop before it */
5041       gtk_tree_path_down (path);
5042     }
5043   else
5044     {
5045       GtkTreeIter iter;
5046       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
5047
5048       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
5049
5050       gtk_tree_model_get_iter (model, &iter, path);
5051
5052       if (!gtk_tree_model_iter_next (model, &iter))
5053         g_object_set_data (G_OBJECT (model), "gtk-tree-model-drop-append",
5054                            GINT_TO_POINTER (1));
5055       else
5056         {
5057           g_object_set_data (G_OBJECT (model), "gtk-tree-model-drop-append",
5058                              NULL);
5059           gtk_tree_path_next (path);
5060         }
5061     }
5062
5063   return path;
5064 }
5065
5066 static gboolean
5067 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
5068                                         GdkEventMotion   *event)
5069 {
5070   GdkDragContext *context;
5071   TreeViewDragInfo *di;
5072   GtkTreePath *path = NULL;
5073   gint button;
5074   gint cell_x, cell_y;
5075   GtkTreeModel *model;
5076   gboolean retval = FALSE;
5077
5078   di = get_info (tree_view);
5079
5080   if (di == NULL)
5081     goto out;
5082
5083   if (tree_view->priv->pressed_button < 0)
5084     goto out;
5085
5086   if (!gtk_drag_check_threshold (GTK_WIDGET (tree_view),
5087                                  tree_view->priv->press_start_x,
5088                                  tree_view->priv->press_start_y,
5089                                  event->x, event->y))
5090     goto out;
5091
5092   model = gtk_tree_view_get_model (tree_view);
5093
5094   if (model == NULL)
5095     goto out;
5096
5097   button = tree_view->priv->pressed_button;
5098   tree_view->priv->pressed_button = -1;
5099
5100   gtk_tree_view_get_path_at_pos (tree_view,
5101                                  tree_view->priv->press_start_x,
5102                                  tree_view->priv->press_start_y,
5103                                  &path,
5104                                  NULL,
5105                                  &cell_x,
5106                                  &cell_y);
5107
5108   if (path == NULL)
5109     goto out;
5110
5111   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
5112       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
5113                                            path))
5114     goto out;
5115
5116   /* FIXME Check whether we're a start button, if not return FALSE and
5117    * free path
5118    */
5119
5120   /* Now we can begin the drag */
5121
5122   retval = TRUE;
5123
5124   context = gtk_drag_begin (GTK_WIDGET (tree_view),
5125                             di->source_target_list,
5126                             di->source_actions,
5127                             button,
5128                             (GdkEvent*)event);
5129
5130   gtk_drag_set_icon_default (context);
5131
5132   {
5133     GdkPixmap *row_pix;
5134
5135     row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
5136                                                   path);
5137
5138     gtk_drag_set_icon_pixmap (context,
5139                               gdk_drawable_get_colormap (row_pix),
5140                               row_pix,
5141                               NULL,
5142                               /* the + 1 is for the black border in the icon */
5143                               tree_view->priv->press_start_x + 1,
5144                               cell_y + 1);
5145
5146     g_object_unref (row_pix);
5147   }
5148
5149   set_source_row (context, model, path);
5150
5151  out:
5152   if (path)
5153     gtk_tree_path_free (path);
5154
5155   return retval;
5156 }
5157
5158
5159 static void
5160 gtk_tree_view_drag_begin (GtkWidget      *widget,
5161                           GdkDragContext *context)
5162 {
5163   /* do nothing */
5164 }
5165
5166 static void
5167 gtk_tree_view_drag_end (GtkWidget      *widget,
5168                         GdkDragContext *context)
5169 {
5170   /* do nothing */
5171 }
5172
5173 /* Default signal implementations for the drag signals */
5174 static void
5175 gtk_tree_view_drag_data_get (GtkWidget        *widget,
5176                              GdkDragContext   *context,
5177                              GtkSelectionData *selection_data,
5178                              guint             info,
5179                              guint             time)
5180 {
5181   GtkTreeView *tree_view;
5182   GtkTreeModel *model;
5183   TreeViewDragInfo *di;
5184   GtkTreePath *source_row;
5185
5186   tree_view = GTK_TREE_VIEW (widget);
5187
5188   model = gtk_tree_view_get_model (tree_view);
5189
5190   if (model == NULL)
5191     return;
5192
5193   di = get_info (GTK_TREE_VIEW (widget));
5194
5195   if (di == NULL)
5196     return;
5197
5198   source_row = get_source_row (context);
5199
5200   if (source_row == NULL)
5201     return;
5202
5203   /* We can implement the GTK_TREE_MODEL_ROW target generically for
5204    * any model; for DragSource models there are some other targets
5205    * we also support.
5206    */
5207
5208   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
5209       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
5210                                           source_row,
5211                                           selection_data))
5212     goto done;
5213
5214   /* If drag_data_get does nothing, try providing row data. */
5215   if (selection_data->target == gdk_atom_intern ("GTK_TREE_MODEL_ROW", FALSE))
5216     {
5217       gtk_tree_set_row_drag_data (selection_data,
5218                                   model,
5219                                   source_row);
5220     }
5221
5222  done:
5223   gtk_tree_path_free (source_row);
5224 }
5225
5226
5227 static void
5228 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
5229                                 GdkDragContext *context)
5230 {
5231   TreeViewDragInfo *di;
5232   GtkTreeModel *model;
5233   GtkTreeView *tree_view;
5234   GtkTreePath *source_row;
5235
5236   tree_view = GTK_TREE_VIEW (widget);
5237   model = gtk_tree_view_get_model (tree_view);
5238
5239   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
5240     return;
5241
5242   di = get_info (tree_view);
5243
5244   if (di == NULL)
5245     return;
5246
5247   source_row = get_source_row (context);
5248
5249   if (source_row == NULL)
5250     return;
5251
5252   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
5253                                          source_row);
5254
5255   gtk_tree_path_free (source_row);
5256
5257   set_source_row (context, NULL, NULL);
5258 }
5259
5260 static void
5261 gtk_tree_view_drag_leave (GtkWidget      *widget,
5262                           GdkDragContext *context,
5263                           guint             time)
5264 {
5265   TreeViewDragInfo *di;
5266
5267   di = get_info (GTK_TREE_VIEW (widget));
5268
5269   /* unset any highlight row */
5270   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
5271                                    NULL,
5272                                    GTK_TREE_VIEW_DROP_BEFORE);
5273
5274   remove_scroll_timeout (GTK_TREE_VIEW (widget));
5275   remove_open_timeout (GTK_TREE_VIEW (widget));
5276 }
5277
5278
5279 static gboolean
5280 gtk_tree_view_drag_motion (GtkWidget        *widget,
5281                            GdkDragContext   *context,
5282                            gint              x,
5283                            gint              y,
5284                            guint             time)
5285 {
5286   GtkTreePath *path = NULL;
5287   GtkTreeViewDropPosition pos;
5288   GtkTreeView *tree_view;
5289   GdkDragAction suggested_action = 0;
5290   GdkAtom target;
5291
5292   tree_view = GTK_TREE_VIEW (widget);
5293
5294   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
5295     return FALSE;
5296
5297   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
5298
5299   if (path == NULL)
5300     {
5301       /* Can't drop here. */
5302       gdk_drag_status (context, 0, time);
5303     }
5304   else
5305     {
5306       if (tree_view->priv->open_dest_timeout == 0 &&
5307           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
5308            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
5309         {
5310           tree_view->priv->open_dest_timeout =
5311             g_timeout_add (500, open_row_timeout, tree_view);
5312         }
5313       else if (tree_view->priv->scroll_timeout == 0)
5314         {
5315           tree_view->priv->scroll_timeout =
5316             g_timeout_add (150, scroll_row_timeout, tree_view);
5317         }
5318
5319       if (target == gdk_atom_intern ("GTK_TREE_MODEL_ROW", FALSE))
5320         {
5321           /* Request data so we can use the source row when
5322            * determining whether to accept the drop
5323            */
5324           set_status_pending (context, suggested_action);
5325           gtk_drag_get_data (widget, context, target, time);
5326         }
5327       else
5328         {
5329           set_status_pending (context, 0);
5330           gdk_drag_status (context, suggested_action, time);
5331         }
5332     }
5333
5334   if (path)
5335     gtk_tree_path_free (path);
5336
5337   return TRUE;
5338 }
5339
5340
5341 static gboolean
5342 gtk_tree_view_drag_drop (GtkWidget        *widget,
5343                          GdkDragContext   *context,
5344                          gint              x,
5345                          gint              y,
5346                          guint             time)
5347 {
5348   GtkTreeView *tree_view;
5349   GtkTreePath *path;
5350   GdkDragAction suggested_action = 0;
5351   GdkAtom target = GDK_NONE;
5352   TreeViewDragInfo *di;
5353   GtkTreeModel *model;
5354
5355   tree_view = GTK_TREE_VIEW (widget);
5356
5357   model = gtk_tree_view_get_model (tree_view);
5358
5359   remove_scroll_timeout (GTK_TREE_VIEW (widget));
5360   remove_open_timeout (GTK_TREE_VIEW (widget));
5361
5362   di = get_info (tree_view);
5363
5364   if (di == NULL)
5365     return FALSE;
5366
5367   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
5368     return FALSE;
5369
5370   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
5371     return FALSE;
5372
5373   path = get_logical_dest_row (tree_view);
5374
5375   if (target != GDK_NONE && path != NULL)
5376     {
5377       /* in case a motion had requested drag data, change things so we
5378        * treat drag data receives as a drop.
5379        */
5380       set_status_pending (context, 0);
5381
5382       set_dest_row (context, model, path);
5383     }
5384
5385   if (path)
5386     gtk_tree_path_free (path);
5387
5388   /* Unset this thing */
5389   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
5390                                    NULL,
5391                                    GTK_TREE_VIEW_DROP_BEFORE);
5392
5393   if (target != GDK_NONE)
5394     {
5395       gtk_drag_get_data (widget, context, target, time);
5396       return TRUE;
5397     }
5398   else
5399     return FALSE;
5400 }
5401
5402 static void
5403 gtk_tree_view_drag_data_received (GtkWidget        *widget,
5404                                   GdkDragContext   *context,
5405                                   gint              x,
5406                                   gint              y,
5407                                   GtkSelectionData *selection_data,
5408                                   guint             info,
5409                                   guint             time)
5410 {
5411   GtkTreePath *path;
5412   TreeViewDragInfo *di;
5413   gboolean accepted = FALSE;
5414   GtkTreeModel *model;
5415   GtkTreeView *tree_view;
5416   GtkTreePath *dest_row;
5417   GdkDragAction suggested_action;
5418
5419   tree_view = GTK_TREE_VIEW (widget);
5420
5421   model = gtk_tree_view_get_model (tree_view);
5422
5423   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
5424     return;
5425
5426   di = get_info (tree_view);
5427
5428   if (di == NULL)
5429     return;
5430
5431   suggested_action = get_status_pending (context);
5432
5433   if (suggested_action)
5434     {
5435       /* We are getting this data due to a request in drag_motion,
5436        * rather than due to a request in drag_drop, so we are just
5437        * supposed to call drag_status, not actually paste in the
5438        * data.
5439        */
5440       path = get_logical_dest_row (tree_view);
5441
5442       if (path == NULL)
5443         suggested_action = 0;
5444
5445       if (suggested_action)
5446         {
5447           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
5448                                                      path,
5449                                                      selection_data))
5450             suggested_action = 0;
5451         }
5452
5453       gdk_drag_status (context, suggested_action, time);
5454
5455       if (path)
5456         gtk_tree_path_free (path);
5457
5458       /* If you can't drop, remove user drop indicator until the next motion */
5459       if (suggested_action == 0)
5460         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
5461                                          NULL,
5462                                          GTK_TREE_VIEW_DROP_BEFORE);
5463
5464       return;
5465     }
5466
5467   dest_row = get_dest_row (context);
5468
5469   if (dest_row == NULL)
5470     return;
5471
5472   if (selection_data->length >= 0)
5473     {
5474       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
5475                                                  dest_row,
5476                                                  selection_data))
5477         accepted = TRUE;
5478     }
5479
5480   gtk_drag_finish (context,
5481                    accepted,
5482                    (context->action == GDK_ACTION_MOVE),
5483                    time);
5484
5485   gtk_tree_path_free (dest_row);
5486
5487   /* drop dest_row */
5488   set_dest_row (context, NULL, NULL);
5489 }
5490
5491
5492
5493 /* GtkContainer Methods
5494  */
5495
5496
5497 static void
5498 gtk_tree_view_remove (GtkContainer *container,
5499                       GtkWidget    *widget)
5500 {
5501   GtkTreeView *tree_view;
5502   GtkTreeViewChild *child = NULL;
5503   GList *tmp_list;
5504
5505   g_return_if_fail (GTK_IS_TREE_VIEW (container));
5506
5507   tree_view = GTK_TREE_VIEW (container);
5508
5509   tmp_list = tree_view->priv->children;
5510   while (tmp_list)
5511     {
5512       child = tmp_list->data;
5513       if (child->widget == widget)
5514         {
5515           gtk_widget_unparent (widget);
5516
5517           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
5518           g_list_free_1 (tmp_list);
5519           g_free (child);
5520           return;
5521         }
5522
5523       tmp_list = tmp_list->next;
5524     }
5525
5526   tmp_list = tree_view->priv->columns;
5527
5528   while (tmp_list)
5529     {
5530       GtkTreeViewColumn *column;
5531       column = tmp_list->data;
5532       if (column->button == widget)
5533         {
5534           gtk_widget_unparent (widget);
5535           return;
5536         }
5537       tmp_list = tmp_list->next;
5538     }
5539 }
5540
5541 static void
5542 gtk_tree_view_forall (GtkContainer *container,
5543                       gboolean      include_internals,
5544                       GtkCallback   callback,
5545                       gpointer      callback_data)
5546 {
5547   GtkTreeView *tree_view;
5548   GtkTreeViewChild *child = NULL;
5549   GtkTreeViewColumn *column;
5550   GList *tmp_list;
5551
5552   g_return_if_fail (GTK_IS_TREE_VIEW (container));
5553   g_return_if_fail (callback != NULL);
5554
5555   tree_view = GTK_TREE_VIEW (container);
5556
5557   tmp_list = tree_view->priv->children;
5558   while (tmp_list)
5559     {
5560       child = tmp_list->data;
5561       tmp_list = tmp_list->next;
5562
5563       (* callback) (child->widget, callback_data);
5564     }
5565   if (include_internals == FALSE)
5566     return;
5567
5568   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
5569     {
5570       column = tmp_list->data;
5571
5572       if (column->button)
5573         (* callback) (column->button, callback_data);
5574     }
5575 }
5576
5577 /* Returns TRUE if the treeview contains no "special" (editable or activatable)
5578  * cells. If so we draw one big row-spanning focus rectangle.
5579  */
5580 static gboolean
5581 gtk_tree_view_has_special_cell (GtkTreeView *tree_view)
5582 {
5583   GList *list;
5584
5585   for (list = tree_view->priv->columns; list; list = list->next)
5586     {
5587       if (!((GtkTreeViewColumn *)list->data)->visible)
5588         continue;
5589       if (_gtk_tree_view_column_count_special_cells (list->data))
5590         return TRUE;
5591     }
5592
5593   return FALSE;
5594 }
5595
5596 /* Returns TRUE if the focus is within the headers, after the focus operation is
5597  * done
5598  */
5599 static gboolean
5600 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
5601                             GtkDirectionType  dir)
5602 {
5603   GtkWidget *focus_child;
5604   GtkContainer *container;
5605
5606   GList *last_column, *first_column;
5607   GList *tmp_list;
5608   gboolean rtl;
5609
5610   if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
5611     return FALSE;
5612
5613   focus_child = GTK_CONTAINER (tree_view)->focus_child;
5614   container = GTK_CONTAINER (tree_view);
5615
5616   first_column = tree_view->priv->columns;
5617   while (first_column)
5618     {
5619       if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (first_column->data)->button) &&
5620           GTK_TREE_VIEW_COLUMN (first_column->data)->visible &&
5621           (GTK_TREE_VIEW_COLUMN (first_column->data)->clickable ||
5622            GTK_TREE_VIEW_COLUMN (first_column->data)->reorderable))
5623         break;
5624       first_column = first_column->next;
5625     }
5626
5627   /* No headers are visible, or are focusable.  We can't focus in or out.
5628    */
5629   if (first_column == NULL)
5630     return FALSE;
5631
5632   last_column = g_list_last (tree_view->priv->columns);
5633   while (last_column)
5634     {
5635       if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (last_column->data)->button) &&
5636           GTK_TREE_VIEW_COLUMN (last_column->data)->visible &&
5637           (GTK_TREE_VIEW_COLUMN (last_column->data)->clickable ||
5638            GTK_TREE_VIEW_COLUMN (last_column->data)->reorderable))
5639         break;
5640       last_column = last_column->prev;
5641     }
5642
5643
5644    rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5645    if (rtl) {
5646      GList *temp = first_column;
5647      first_column = last_column;
5648      last_column = temp;
5649    }
5650
5651   switch (dir)
5652     {
5653     case GTK_DIR_TAB_BACKWARD:
5654     case GTK_DIR_TAB_FORWARD:
5655     case GTK_DIR_UP:
5656     case GTK_DIR_DOWN:
5657       if (focus_child == NULL)
5658         {
5659           if (tree_view->priv->focus_column != NULL)
5660             focus_child = tree_view->priv->focus_column->button;
5661           else
5662             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
5663           gtk_widget_grab_focus (focus_child);
5664           break;
5665         }
5666       return FALSE;
5667
5668     case GTK_DIR_LEFT:
5669     case GTK_DIR_RIGHT:
5670       if (focus_child == NULL)
5671         {
5672           if (tree_view->priv->focus_column != NULL)
5673             focus_child = tree_view->priv->focus_column->button;
5674           else if (dir == GTK_DIR_LEFT)
5675             focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
5676           else
5677             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
5678           gtk_widget_grab_focus (focus_child);
5679           break;
5680         }
5681
5682       if (gtk_widget_child_focus (focus_child, dir))
5683         {
5684           /* The focus moves inside the button. */
5685           /* This is probably a great example of bad UI */
5686           break;
5687         }
5688
5689       /* We need to move the focus among the row of buttons. */
5690       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
5691         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
5692           break;
5693
5694       if (tmp_list == first_column && dir == GTK_DIR_LEFT)
5695         {
5696           focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
5697           gtk_widget_grab_focus (focus_child);
5698           break;
5699         }
5700       else if (tmp_list == last_column && dir == GTK_DIR_RIGHT)
5701         {
5702           focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
5703           gtk_widget_grab_focus (focus_child);
5704           break;
5705         }
5706
5707       while (tmp_list)
5708         {
5709           GtkTreeViewColumn *column;
5710
5711           if (dir == GTK_DIR_RIGHT)
5712             tmp_list = tmp_list->next;
5713           else
5714             tmp_list = tmp_list->prev;
5715
5716           if (tmp_list == NULL)
5717             {
5718               g_warning ("Internal button not found");
5719               break;
5720             }
5721           column = tmp_list->data;
5722           if (column->button &&
5723               column->visible &&
5724               GTK_WIDGET_CAN_FOCUS (column->button))
5725             {
5726               focus_child = column->button;
5727               gtk_widget_grab_focus (column->button);
5728               break;
5729             }
5730         }
5731       break;
5732     default:
5733       g_assert_not_reached ();
5734       break;
5735     }
5736
5737   /* if focus child is non-null, we assume it's been set to the current focus child
5738    */
5739   if (focus_child)
5740     {
5741       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
5742         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
5743           break;
5744
5745       tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5746
5747       /* If the following isn't true, then the view is smaller then the scrollpane.
5748        */
5749       if ((focus_child->allocation.x + focus_child->allocation.width) <=
5750           (tree_view->priv->hadjustment->upper))
5751         {
5752           /* Scroll to the button, if needed */
5753           if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) <
5754               (focus_child->allocation.x + focus_child->allocation.width))
5755             gtk_adjustment_set_value (tree_view->priv->hadjustment,
5756                                       focus_child->allocation.x + focus_child->allocation.width -
5757                                       tree_view->priv->hadjustment->page_size);
5758           else if (tree_view->priv->hadjustment->value > focus_child->allocation.x)
5759             gtk_adjustment_set_value (tree_view->priv->hadjustment,
5760                                       focus_child->allocation.x);
5761         }
5762     }
5763
5764   return (focus_child != NULL);
5765 }
5766
5767 static gint
5768 gtk_tree_view_focus (GtkWidget        *widget,
5769                      GtkDirectionType  direction)
5770 {
5771   GtkTreeView *tree_view;
5772   GtkWidget *focus_child;
5773   GtkContainer *container;
5774
5775   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
5776   g_return_val_if_fail (GTK_WIDGET_VISIBLE (widget), FALSE);
5777
5778   container = GTK_CONTAINER (widget);
5779   tree_view = GTK_TREE_VIEW (widget);
5780
5781   if (!GTK_WIDGET_IS_SENSITIVE (container))
5782     return FALSE;
5783
5784   focus_child = container->focus_child;
5785
5786   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
5787   /* Case 1.  Headers currently have focus. */
5788   if (focus_child)
5789     {
5790       switch (direction)
5791         {
5792         case GTK_DIR_LEFT:
5793         case GTK_DIR_RIGHT:
5794           gtk_tree_view_header_focus (tree_view, direction);
5795           return TRUE;
5796         case GTK_DIR_TAB_BACKWARD:
5797         case GTK_DIR_UP:
5798           return FALSE;
5799         case GTK_DIR_TAB_FORWARD:
5800         case GTK_DIR_DOWN:
5801           if (tree_view->priv->tree == NULL)
5802             return FALSE;
5803           gtk_widget_grab_focus (widget);
5804           return TRUE;
5805         }
5806     }
5807
5808   /* Case 2. We don't have focus at all. */
5809   if (!GTK_WIDGET_HAS_FOCUS (container))
5810     {
5811       if (tree_view->priv->tree == NULL &&
5812           (direction == GTK_DIR_TAB_BACKWARD ||
5813            direction == GTK_DIR_UP))
5814         return gtk_tree_view_header_focus (tree_view, direction);
5815       if (((direction == GTK_DIR_TAB_FORWARD) ||
5816            (direction == GTK_DIR_RIGHT) ||
5817            (direction == GTK_DIR_DOWN) ||
5818            (direction == GTK_DIR_LEFT)) &&
5819           gtk_tree_view_header_focus (tree_view, direction))
5820         return TRUE;
5821
5822       if (tree_view->priv->tree == NULL)
5823         return FALSE;
5824       gtk_widget_grab_focus (widget);
5825       return TRUE;
5826     }
5827
5828   /* Case 3. We have focus already. */
5829   if (tree_view->priv->tree == NULL)
5830     return gtk_tree_view_header_focus (tree_view, direction);
5831
5832   if (direction == GTK_DIR_TAB_BACKWARD)
5833     return (gtk_tree_view_header_focus (tree_view, direction));
5834   else if (direction == GTK_DIR_TAB_FORWARD)
5835     return FALSE;
5836
5837   /* Other directions caught by the keybindings */
5838   gtk_widget_grab_focus (widget);
5839   return TRUE;
5840 }
5841
5842 static void
5843 gtk_tree_view_grab_focus (GtkWidget *widget)
5844 {
5845   (* GTK_WIDGET_CLASS (parent_class)->grab_focus) (widget);
5846
5847   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
5848 }
5849
5850 static void
5851 gtk_tree_view_style_set (GtkWidget *widget,
5852                          GtkStyle *previous_style)
5853 {
5854   GtkTreeView *tree_view;
5855   GList *list;
5856   GtkTreeViewColumn *column;
5857
5858   g_return_if_fail (GTK_IS_TREE_VIEW (widget));
5859
5860   tree_view = GTK_TREE_VIEW (widget);
5861
5862   if (GTK_WIDGET_REALIZED (widget))
5863     {
5864       gdk_window_set_background (widget->window, &widget->style->base[widget->state]);
5865       gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
5866     }
5867
5868   gtk_widget_style_get (widget,
5869                         "expander_size", &tree_view->priv->expander_size,
5870                         NULL);
5871   tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
5872
5873   for (list = tree_view->priv->columns; list; list = list->next)
5874     {
5875       column = list->data;
5876       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
5877     }
5878
5879   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
5880
5881   gtk_widget_queue_resize (widget);
5882 }
5883
5884
5885 static void
5886 gtk_tree_view_set_focus_child (GtkContainer *container,
5887                                GtkWidget    *child)
5888 {
5889   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
5890   GList *list;
5891
5892   for (list = tree_view->priv->columns; list; list = list->next)
5893     {
5894       if (GTK_TREE_VIEW_COLUMN (list->data)->button == child)
5895         {
5896           tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
5897           break;
5898         }
5899     }
5900
5901   (* parent_class->set_focus_child) (container, child);
5902 }
5903
5904 static void
5905 gtk_tree_view_set_adjustments (GtkTreeView   *tree_view,
5906                                GtkAdjustment *hadj,
5907                                GtkAdjustment *vadj)
5908 {
5909   gboolean need_adjust = FALSE;
5910
5911   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
5912
5913   if (hadj)
5914     g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
5915   else
5916     hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
5917   if (vadj)
5918     g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
5919   else
5920     vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
5921
5922   if (tree_view->priv->hadjustment && (tree_view->priv->hadjustment != hadj))
5923     {
5924       g_signal_handlers_disconnect_by_func (tree_view->priv->hadjustment,
5925                                             gtk_tree_view_adjustment_changed,
5926                                             tree_view);
5927       g_object_unref (tree_view->priv->hadjustment);
5928     }
5929
5930   if (tree_view->priv->vadjustment && (tree_view->priv->vadjustment != vadj))
5931     {
5932       g_signal_handlers_disconnect_by_func (tree_view->priv->vadjustment,
5933                                             gtk_tree_view_adjustment_changed,
5934                                             tree_view);
5935       g_object_unref (tree_view->priv->vadjustment);
5936     }
5937
5938   if (tree_view->priv->hadjustment != hadj)
5939     {
5940       tree_view->priv->hadjustment = hadj;
5941       g_object_ref (tree_view->priv->hadjustment);
5942       gtk_object_sink (GTK_OBJECT (tree_view->priv->hadjustment));
5943
5944       g_signal_connect (tree_view->priv->hadjustment, "value_changed",
5945                         G_CALLBACK (gtk_tree_view_adjustment_changed),
5946                         tree_view);
5947       need_adjust = TRUE;
5948     }
5949
5950   if (tree_view->priv->vadjustment != vadj)
5951     {
5952       tree_view->priv->vadjustment = vadj;
5953       g_object_ref (tree_view->priv->vadjustment);
5954       gtk_object_sink (GTK_OBJECT (tree_view->priv->vadjustment));
5955
5956       g_signal_connect (tree_view->priv->vadjustment, "value_changed",
5957                         G_CALLBACK (gtk_tree_view_adjustment_changed),
5958                         tree_view);
5959       need_adjust = TRUE;
5960     }
5961
5962   if (need_adjust)
5963     gtk_tree_view_adjustment_changed (NULL, tree_view);
5964 }
5965
5966
5967 static gboolean
5968 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
5969                                 GtkMovementStep    step,
5970                                 gint               count)
5971 {
5972   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
5973   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
5974                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
5975                         step == GTK_MOVEMENT_DISPLAY_LINES ||
5976                         step == GTK_MOVEMENT_PAGES ||
5977                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
5978
5979   if (tree_view->priv->tree == NULL)
5980     return FALSE;
5981   if (!GTK_WIDGET_HAS_FOCUS (GTK_WIDGET (tree_view)))
5982     return FALSE;
5983
5984   gtk_tree_view_stop_editing (tree_view, FALSE);
5985   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
5986   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5987
5988   switch (step)
5989     {
5990       /* currently we make no distinction.  When we go bi-di, we need to */
5991     case GTK_MOVEMENT_LOGICAL_POSITIONS:
5992     case GTK_MOVEMENT_VISUAL_POSITIONS:
5993       gtk_tree_view_move_cursor_left_right (tree_view, count);
5994       break;
5995     case GTK_MOVEMENT_DISPLAY_LINES:
5996       gtk_tree_view_move_cursor_up_down (tree_view, count);
5997       break;
5998     case GTK_MOVEMENT_PAGES:
5999       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
6000       break;
6001     case GTK_MOVEMENT_BUFFER_ENDS:
6002       gtk_tree_view_move_cursor_start_end (tree_view, count);
6003       break;
6004     default:
6005       g_assert_not_reached ();
6006     }
6007
6008   return TRUE;
6009 }
6010
6011 static void
6012 gtk_tree_view_put (GtkTreeView *tree_view,
6013                    GtkWidget   *child_widget,
6014                    gint         x,
6015                    gint         y,
6016                    gint         width,
6017                    gint         height)
6018 {
6019   GtkTreeViewChild *child;
6020
6021   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6022   g_return_if_fail (GTK_IS_WIDGET (child_widget));
6023
6024   child = g_new (GtkTreeViewChild, 1);
6025
6026   child->widget = child_widget;
6027   child->x = x;
6028   child->y = y;
6029   child->width = width;
6030   child->height = height;
6031
6032   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
6033
6034   if (GTK_WIDGET_REALIZED (tree_view))
6035     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
6036
6037   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
6038 }
6039
6040 void
6041 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
6042                                   GtkWidget   *widget,
6043                                   gint         x,
6044                                   gint         y,
6045                                   gint         width,
6046                                   gint         height)
6047 {
6048   GtkTreeViewChild *child = NULL;
6049   GList *list;
6050   GdkRectangle allocation;
6051
6052   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6053   g_return_if_fail (GTK_IS_WIDGET (widget));
6054
6055   for (list = tree_view->priv->children; list; list = list->next)
6056     {
6057       if (((GtkTreeViewChild *)list->data)->widget == widget)
6058         {
6059           child = list->data;
6060           break;
6061         }
6062     }
6063   if (child == NULL)
6064     return;
6065
6066   allocation.x = child->x = x;
6067   allocation.y = child->y = y;
6068   allocation.width = child->width = width;
6069   allocation.height = child->height = height;
6070
6071   if (GTK_WIDGET_REALIZED (widget))
6072     gtk_widget_size_allocate (widget, &allocation);
6073 }
6074
6075
6076 /* TreeModel Callbacks
6077  */
6078
6079 static void
6080 gtk_tree_view_row_changed (GtkTreeModel *model,
6081                            GtkTreePath  *path,
6082                            GtkTreeIter  *iter,
6083                            gpointer      data)
6084 {
6085   GtkTreeView *tree_view = (GtkTreeView *)data;
6086   GtkRBTree *tree;
6087   GtkRBNode *node;
6088   gboolean free_path = FALSE;
6089   gint vertical_separator;
6090   GList *list;
6091
6092   g_return_if_fail (path != NULL || iter != NULL);
6093
6094   if (!GTK_WIDGET_REALIZED (tree_view))
6095     /* We can just ignore ::changed signals if we aren't realized, as we don't care about sizes
6096      */
6097     return;
6098
6099   if (tree_view->priv->edited_column)
6100     gtk_tree_view_stop_editing (tree_view, TRUE);
6101
6102   gtk_widget_style_get (GTK_WIDGET (data), "vertical_separator", &vertical_separator, NULL);
6103
6104   if (path == NULL)
6105     {
6106       path = gtk_tree_model_get_path (model, iter);
6107       free_path = TRUE;
6108     }
6109   else if (iter == NULL)
6110     gtk_tree_model_get_iter (model, iter, path);
6111
6112   if (_gtk_tree_view_find_node (tree_view,
6113                                 path,
6114                                 &tree,
6115                                 &node))
6116     /* We aren't actually showing the node */
6117     goto done;
6118
6119   if (tree == NULL)
6120     goto done;
6121
6122   _gtk_rbtree_node_mark_invalid (tree, node);
6123   for (list = tree_view->priv->columns; list; list = list->next)
6124     {
6125       GtkTreeViewColumn *column;
6126
6127       column = list->data;
6128       if (! column->visible)
6129         continue;
6130
6131       if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
6132         {
6133           _gtk_tree_view_column_cell_set_dirty (column, TRUE);
6134         }
6135     }
6136
6137  done:
6138   install_presize_handler (tree_view);
6139   if (free_path)
6140     gtk_tree_path_free (path);
6141 }
6142
6143 static void
6144 gtk_tree_view_row_inserted (GtkTreeModel *model,
6145                             GtkTreePath  *path,
6146                             GtkTreeIter  *iter,
6147                             gpointer      data)
6148 {
6149   GtkTreeView *tree_view = (GtkTreeView *) data;
6150   gint *indices;
6151   GtkRBTree *tmptree, *tree;
6152   GtkRBNode *tmpnode = NULL;
6153   gint depth;
6154   gint i = 0;
6155   gboolean free_path = FALSE;
6156
6157   g_return_if_fail (path != NULL || iter != NULL);
6158
6159   if (path == NULL)
6160     {
6161       path = gtk_tree_model_get_path (model, iter);
6162       free_path = TRUE;
6163     }
6164   else if (iter == NULL)
6165     gtk_tree_model_get_iter (model, iter, path);
6166
6167   if (tree_view->priv->tree == NULL)
6168     tree_view->priv->tree = _gtk_rbtree_new ();
6169
6170   tmptree = tree = tree_view->priv->tree;
6171
6172   /* Update all row-references */
6173   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
6174   depth = gtk_tree_path_get_depth (path);
6175   indices = gtk_tree_path_get_indices (path);
6176
6177   /* First, find the parent tree */
6178   while (i < depth - 1)
6179     {
6180       if (tmptree == NULL)
6181         {
6182           /* We aren't showing the node */
6183           goto done;
6184         }
6185
6186       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
6187       if (tmpnode == NULL)
6188         {
6189           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
6190                      "This possibly means that a GtkTreeModel inserted a child node\n" \
6191                      "before the parent was inserted.");
6192           goto done;
6193         }
6194       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
6195         {
6196           /* FIXME enforce correct behavior on model, probably */
6197           /* In theory, the model should have emitted has_child_toggled here.  We
6198            * try to catch it anyway, just to be safe, in case the model hasn't.
6199            */
6200           GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
6201                                                            tree,
6202                                                            tmpnode);
6203           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
6204           gtk_tree_path_free (tmppath);
6205           goto done;
6206         }
6207
6208       tmptree = tmpnode->children;
6209       tree = tmptree;
6210       i++;
6211     }
6212
6213   if (tree == NULL)
6214     goto done;
6215
6216   /* ref the node */
6217   gtk_tree_model_ref_node (tree_view->priv->model, iter);
6218   if (indices[depth - 1] == 0)
6219     {
6220       tmpnode = _gtk_rbtree_find_count (tree, 1);
6221       _gtk_rbtree_insert_before (tree, tmpnode, 0, FALSE);
6222     }
6223   else
6224     {
6225       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
6226       _gtk_rbtree_insert_after (tree, tmpnode, 0, FALSE);
6227     }
6228
6229  done:
6230   install_presize_handler (tree_view);
6231   if (free_path)
6232     gtk_tree_path_free (path);
6233 }
6234
6235 static void
6236 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
6237                                      GtkTreePath  *path,
6238                                      GtkTreeIter  *iter,
6239                                      gpointer      data)
6240 {
6241   GtkTreeView *tree_view = (GtkTreeView *)data;
6242   GtkTreeIter real_iter;
6243   gboolean has_child;
6244   GtkRBTree *tree;
6245   GtkRBNode *node;
6246   gboolean free_path = FALSE;
6247
6248   g_return_if_fail (path != NULL || iter != NULL);
6249
6250   if (iter)
6251     real_iter = *iter;
6252
6253   if (path == NULL)
6254     {
6255       path = gtk_tree_model_get_path (model, iter);
6256       free_path = TRUE;
6257     }
6258   else if (iter == NULL)
6259     gtk_tree_model_get_iter (model, &real_iter, path);
6260
6261   if (_gtk_tree_view_find_node (tree_view,
6262                                 path,
6263                                 &tree,
6264                                 &node))
6265     /* We aren't actually showing the node */
6266     goto done;
6267
6268   if (tree == NULL)
6269     goto done;
6270
6271   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
6272   /* Sanity check.
6273    */
6274   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
6275     goto done;
6276
6277   if (has_child)
6278     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
6279   else
6280     GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
6281
6282   if (has_child && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
6283     {
6284       GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
6285       if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS))
6286         {
6287           GList *list;
6288
6289           for (list = tree_view->priv->columns; list; list = list->next)
6290             if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
6291               {
6292                 GTK_TREE_VIEW_COLUMN (list->data)->dirty = TRUE;
6293                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
6294                 break;
6295               }
6296         }
6297       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6298     }
6299   else
6300     {
6301       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6302     }
6303
6304  done:
6305   if (free_path)
6306     gtk_tree_path_free (path);
6307 }
6308
6309 static void
6310 count_children_helper (GtkRBTree *tree,
6311                        GtkRBNode *node,
6312                        gpointer   data)
6313 {
6314   if (node->children)
6315     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
6316   (*((gint *)data))++;
6317 }
6318
6319 static void
6320 gtk_tree_view_row_deleted (GtkTreeModel *model,
6321                            GtkTreePath  *path,
6322                            gpointer      data)
6323 {
6324   GtkTreeView *tree_view = (GtkTreeView *)data;
6325   GtkRBTree *tree;
6326   GtkRBNode *node;
6327   GList *list;
6328   gint selection_changed;
6329
6330   g_return_if_fail (path != NULL);
6331
6332   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
6333
6334   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
6335     return;
6336
6337   if (tree == NULL)
6338     return;
6339
6340   /* Change the selection */
6341   selection_changed = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
6342
6343   for (list = tree_view->priv->columns; list; list = list->next)
6344     if (((GtkTreeViewColumn *)list->data)->visible &&
6345         ((GtkTreeViewColumn *)list->data)->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
6346       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
6347
6348   /* Ensure we don't have a dangling pointer to a dead node */
6349   ensure_unprelighted (tree_view);
6350
6351   /* Cancel editting if we've started */
6352   gtk_tree_view_stop_editing (tree_view, TRUE);
6353
6354   /* If we have a node expanded/collapsed timeout, remove it */
6355   if (tree_view->priv->expand_collapse_timeout != 0)
6356     {
6357       g_source_remove (tree_view->priv->expand_collapse_timeout);
6358       tree_view->priv->expand_collapse_timeout = 0;
6359
6360       /* Reset node */
6361       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_COLLAPSED);
6362       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_EXPANDED);
6363       tree_view->priv->expanded_collapsed_node = NULL;
6364     }
6365
6366   if (tree_view->priv->destroy_count_func)
6367     {
6368       gint child_count = 0;
6369       if (node->children)
6370         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
6371       (* tree_view->priv->destroy_count_func) (tree_view, path, child_count, tree_view->priv->destroy_count_data);
6372     }
6373
6374   if (tree->root->count == 1)
6375     {
6376       if (tree_view->priv->tree == tree)
6377         tree_view->priv->tree = NULL;
6378
6379       _gtk_rbtree_remove (tree);
6380     }
6381   else
6382     {
6383       _gtk_rbtree_remove_node (tree, node);
6384     }
6385
6386   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
6387     {
6388       gtk_tree_row_reference_free (tree_view->priv->top_row);
6389       tree_view->priv->top_row = NULL;
6390     }
6391
6392   install_scroll_sync_handler (tree_view);
6393
6394   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6395
6396   if (selection_changed)
6397     g_signal_emit_by_name (tree_view->priv->selection, "changed");
6398 }
6399
6400 static void
6401 cancel_arrow_animation (GtkTreeView *tree_view)
6402 {
6403   if (tree_view->priv->expand_collapse_timeout)
6404     while (expand_collapse_timeout (tree_view));
6405   tree_view->priv->expand_collapse_timeout = 0;
6406 }
6407
6408 static void
6409 gtk_tree_view_rows_reordered (GtkTreeModel *model,
6410                               GtkTreePath  *parent,
6411                               GtkTreeIter  *iter,
6412                               gint         *new_order,
6413                               gpointer      data)
6414 {
6415   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
6416   GtkRBTree *tree;
6417   GtkRBNode *node;
6418   gint len;
6419
6420   len = gtk_tree_model_iter_n_children (model, iter);
6421
6422   if (len < 2)
6423     return;
6424
6425   gtk_tree_row_reference_reordered (G_OBJECT (data),
6426                                     parent,
6427                                     iter,
6428                                     new_order);
6429
6430   if (_gtk_tree_view_find_node (tree_view,
6431                                 parent,
6432                                 &tree,
6433                                 &node))
6434     return;
6435
6436   /* We need to special case the parent path */
6437   if (tree == NULL)
6438     tree = tree_view->priv->tree;
6439   else
6440     tree = node->children;
6441
6442   if (tree == NULL)
6443     return;
6444
6445   /* we need to be unprelighted */
6446   ensure_unprelighted (tree_view);
6447
6448   /* clear the timeout */
6449   cancel_arrow_animation (tree_view);
6450
6451   _gtk_rbtree_reorder (tree, new_order, len);
6452
6453   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6454
6455   gtk_tree_view_dy_to_top_row (tree_view);
6456 }
6457
6458
6459 /* Internal tree functions
6460  */
6461
6462
6463 static void
6464 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
6465                                      GtkRBTree         *tree,
6466                                      GtkTreeViewColumn *column,
6467                                      gint              *x1,
6468                                      gint              *x2)
6469 {
6470   GtkTreeViewColumn *tmp_column = NULL;
6471   gint total_width;
6472   GList *list;
6473   gboolean rtl;
6474
6475   if (x1)
6476     *x1 = 0;
6477
6478   if (x2)
6479     *x2 = 0;
6480
6481   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
6482
6483   total_width = 0;
6484   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
6485        list;
6486        list = (rtl ? list->prev : list->next))
6487     {
6488       tmp_column = list->data;
6489
6490       if (tmp_column == column)
6491         break;
6492
6493       if (tmp_column->visible)
6494         total_width += tmp_column->width;
6495     }
6496
6497   if (tmp_column != column)
6498     {
6499       g_warning (G_STRLOC": passed-in column isn't in the tree");
6500       return;
6501     }
6502
6503   if (x1)
6504     *x1 = total_width;
6505
6506   if (x2)
6507     {
6508       if (column->visible)
6509         *x2 = total_width + column->width;
6510       else
6511         *x2 = total_width; /* width of 0 */
6512     }
6513 }
6514 static void
6515 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
6516                                 GtkRBTree   *tree,
6517                                 gint        *x1,
6518                                 gint        *x2)
6519 {
6520   gint x_offset = 0;
6521   GList *list;
6522   GtkTreeViewColumn *tmp_column = NULL;
6523   gint total_width;
6524   gboolean indent_expanders;
6525   gboolean rtl;
6526
6527   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
6528
6529   total_width = 0;
6530   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
6531        list;
6532        list = (rtl ? list->prev : list->next))
6533     {
6534       tmp_column = list->data;
6535
6536       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
6537         {
6538           if (rtl)
6539             x_offset = total_width + tmp_column->width - tree_view->priv->expander_size;
6540           else
6541             x_offset = total_width;
6542           break;
6543         }
6544
6545       if (tmp_column->visible)
6546         total_width += tmp_column->width;
6547     }
6548
6549   gtk_widget_style_get (GTK_WIDGET (tree_view),
6550                         "indent_expanders", &indent_expanders,
6551                         NULL);
6552
6553   if (indent_expanders)
6554     {
6555       if (rtl)
6556         x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
6557       else
6558         x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
6559     }
6560   if (x1)
6561     {
6562       *x1 = x_offset;
6563     }
6564
6565   if (tmp_column && tmp_column->visible)
6566     {
6567       /* +1 because x2 isn't included in the range. */
6568       if (x2)
6569         *x2 = *x1 + tree_view->priv->expander_size + 1;
6570     }
6571   else
6572     {
6573       /* return an empty range, the expander column is hidden */
6574       if (x2)
6575         *x2 = *x1;
6576     }
6577 }
6578
6579 static void
6580 gtk_tree_view_build_tree (GtkTreeView *tree_view,
6581                           GtkRBTree   *tree,
6582                           GtkTreeIter *iter,
6583                           gint         depth,
6584                           gboolean     recurse)
6585 {
6586   GtkRBNode *temp = NULL;
6587
6588   do
6589     {
6590       gtk_tree_model_ref_node (tree_view->priv->model, iter);
6591       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
6592       if (recurse)
6593         {
6594           GtkTreeIter child;
6595
6596           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
6597             {
6598               temp->children = _gtk_rbtree_new ();
6599               temp->children->parent_tree = tree;
6600               temp->children->parent_node = temp;
6601               gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
6602             }
6603         }
6604       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
6605         {
6606           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
6607             temp->flags ^= GTK_RBNODE_IS_PARENT;
6608           GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
6609         }
6610     }
6611   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
6612 }
6613
6614 /* If height is non-NULL, then we set it to be the new height.  if it's all
6615  * dirty, then height is -1.  We know we'll remeasure dirty rows, anyways.
6616  */
6617 static gboolean
6618 gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view,
6619                                    GtkTreeIter *iter,
6620                                    gint         depth,
6621                                    gint        *height,
6622                                    GtkRBNode   *node)
6623 {
6624   GtkTreeViewColumn *column;
6625   GList *list;
6626   gboolean retval = FALSE;
6627   gint tmpheight;
6628   gint horizontal_separator;
6629
6630   gtk_widget_style_get (GTK_WIDGET (tree_view),
6631                         "horizontal_separator", &horizontal_separator,
6632                         NULL);
6633
6634   if (height)
6635     *height = -1;
6636
6637   for (list = tree_view->priv->columns; list; list = list->next)
6638     {
6639       gint width;
6640       column = list->data;
6641       if (column->dirty == TRUE)
6642         continue;
6643       if (height == NULL && column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
6644         continue;
6645       if (!column->visible)
6646         continue;
6647
6648       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
6649                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
6650                                                node->children?TRUE:FALSE);
6651
6652       if (height)
6653         {
6654           gtk_tree_view_column_cell_get_size (column,
6655                                               NULL, NULL, NULL,
6656                                               &width, &tmpheight);
6657           *height = MAX (*height, tmpheight);
6658         }
6659       else
6660         {
6661           gtk_tree_view_column_cell_get_size (column,
6662                                               NULL, NULL, NULL,
6663                                               &width, NULL);
6664         }
6665
6666       if (gtk_tree_view_is_expander_column (tree_view, column) &&
6667           TREE_VIEW_DRAW_EXPANDERS (tree_view))
6668         {
6669           if (depth * tree_view->priv->expander_size + horizontal_separator + width > column->requested_width)
6670             {
6671               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
6672               retval = TRUE;
6673             }
6674         }
6675       else
6676         {
6677           if (horizontal_separator + width > column->requested_width)
6678             {
6679               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
6680               retval = TRUE;
6681             }
6682         }
6683     }
6684
6685   return retval;
6686 }
6687
6688 static void
6689 gtk_tree_view_discover_dirty (GtkTreeView *tree_view,
6690                               GtkRBTree   *tree,
6691                               GtkTreeIter *iter,
6692                               gint         depth)
6693 {
6694   GtkRBNode *temp = tree->root;
6695   GtkTreeViewColumn *column;
6696   GList *list;
6697   GtkTreeIter child;
6698   gboolean is_all_dirty;
6699
6700   TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
6701
6702   while (temp->left != tree->nil)
6703     temp = temp->left;
6704
6705   do
6706     {
6707       TREE_VIEW_INTERNAL_ASSERT_VOID (temp != NULL);
6708       is_all_dirty = TRUE;
6709       for (list = tree_view->priv->columns; list; list = list->next)
6710         {
6711           column = list->data;
6712           if (column->dirty == FALSE)
6713             {
6714               is_all_dirty = FALSE;
6715               break;
6716             }
6717         }
6718
6719       if (is_all_dirty)
6720         return;
6721
6722       gtk_tree_view_discover_dirty_iter (tree_view,
6723                                          iter,
6724                                          depth,
6725                                          NULL,
6726                                          temp);
6727       if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter) &&
6728           temp->children != NULL)
6729         gtk_tree_view_discover_dirty (tree_view, temp->children, &child, depth + 1);
6730       temp = _gtk_rbtree_next (tree, temp);
6731     }
6732   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
6733 }
6734
6735
6736 /* Make sure the node is visible vertically */
6737 static void
6738 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
6739                                   GtkRBTree   *tree,
6740                                   GtkRBNode   *node)
6741 {
6742   GtkTreePath *path = NULL;
6743
6744   if (!GTK_WIDGET_REALIZED (tree_view))
6745     return;
6746
6747   path = _gtk_tree_view_find_path (tree_view, tree, node);
6748
6749   if (path)
6750     {
6751       /* We process updates because we want to clear old selected items when we scroll.
6752        * if this is removed, we get a "selection streak" at the bottom. */
6753       gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
6754       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
6755       gtk_tree_path_free (path);
6756     }
6757 }
6758
6759 static void
6760 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
6761                                     GtkTreeViewColumn *column)
6762 {
6763   if (column == NULL)
6764     return;
6765   if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) <
6766       (column->button->allocation.x + column->button->allocation.width))
6767     gtk_adjustment_set_value (tree_view->priv->hadjustment,
6768                               column->button->allocation.x + column->button->allocation.width -
6769                               tree_view->priv->hadjustment->page_size);
6770   else if (tree_view->priv->hadjustment->value > column->button->allocation.x)
6771     gtk_adjustment_set_value (tree_view->priv->hadjustment,
6772                               column->button->allocation.x);
6773 }
6774
6775 /* This function could be more efficient.  I'll optimize it if profiling seems
6776  * to imply that it is important */
6777 GtkTreePath *
6778 _gtk_tree_view_find_path (GtkTreeView *tree_view,
6779                           GtkRBTree   *tree,
6780                           GtkRBNode   *node)
6781 {
6782   GtkTreePath *path;
6783   GtkRBTree *tmp_tree;
6784   GtkRBNode *tmp_node, *last;
6785   gint count;
6786
6787   path = gtk_tree_path_new ();
6788
6789   g_return_val_if_fail (node != NULL, path);
6790   g_return_val_if_fail (node != tree->nil, path);
6791
6792   count = 1 + node->left->count;
6793
6794   last = node;
6795   tmp_node = node->parent;
6796   tmp_tree = tree;
6797   while (tmp_tree)
6798     {
6799       while (tmp_node != tmp_tree->nil)
6800         {
6801           if (tmp_node->right == last)
6802             count += 1 + tmp_node->left->count;
6803           last = tmp_node;
6804           tmp_node = tmp_node->parent;
6805         }
6806       gtk_tree_path_prepend_index (path, count - 1);
6807       last = tmp_tree->parent_node;
6808       tmp_tree = tmp_tree->parent_tree;
6809       if (last)
6810         {
6811           count = 1 + last->left->count;
6812           tmp_node = last->parent;
6813         }
6814     }
6815   return path;
6816 }
6817
6818 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
6819  * invalid (ie. points to a node that's not in the tree), *tree and *node are
6820  * both set to NULL.
6821  */
6822 gboolean
6823 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
6824                           GtkTreePath  *path,
6825                           GtkRBTree   **tree,
6826                           GtkRBNode   **node)
6827 {
6828   GtkRBNode *tmpnode = NULL;
6829   GtkRBTree *tmptree = tree_view->priv->tree;
6830   gint *indices = gtk_tree_path_get_indices (path);
6831   gint depth = gtk_tree_path_get_depth (path);
6832   gint i = 0;
6833
6834   *node = NULL;
6835   *tree = NULL;
6836
6837   if (depth == 0 || tmptree == NULL)
6838     return FALSE;
6839   do
6840     {
6841       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
6842       ++i;
6843       if (tmpnode == NULL)
6844         {
6845           *tree = NULL;
6846           *node = NULL;
6847           return FALSE;
6848         }
6849       if (i >= depth)
6850         {
6851           *tree = tmptree;
6852           *node = tmpnode;
6853           return FALSE;
6854         }
6855       *tree = tmptree;
6856       *node = tmpnode;
6857       tmptree = tmpnode->children;
6858       if (tmptree == NULL)
6859         return TRUE;
6860     }
6861   while (1);
6862 }
6863
6864 static gboolean
6865 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
6866                                   GtkTreeViewColumn *column)
6867 {
6868   GList *list;
6869
6870   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
6871     return FALSE;
6872
6873   if (tree_view->priv->expander_column != NULL)
6874     {
6875       if (tree_view->priv->expander_column == column)
6876         return TRUE;
6877       return FALSE;
6878     }
6879   else
6880     {
6881       for (list = tree_view->priv->columns;
6882            list;
6883            list = list->next)
6884         if (((GtkTreeViewColumn *)list->data)->visible)
6885           break;
6886       if (list && list->data == column)
6887         return TRUE;
6888     }
6889   return FALSE;
6890 }
6891
6892 static void
6893 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
6894                                 guint           keyval,
6895                                 guint           modmask,
6896                                 GtkMovementStep step,
6897                                 gint            count)
6898 {
6899
6900   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
6901                                 "move_cursor", 2,
6902                                 G_TYPE_ENUM, step,
6903                                 G_TYPE_INT, count);
6904
6905   gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
6906                                 "move_cursor", 2,
6907                                 G_TYPE_ENUM, step,
6908                                 G_TYPE_INT, count);
6909
6910   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
6911    return;
6912
6913   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
6914                                 "move_cursor", 2,
6915                                 G_TYPE_ENUM, step,
6916                                 G_TYPE_INT, count);
6917
6918   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
6919                                 "move_cursor", 2,
6920                                 G_TYPE_ENUM, step,
6921                                 G_TYPE_INT, count);
6922 }
6923
6924 static gint
6925 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
6926                                  GtkTreeIter  *iter,
6927                                  GtkRBTree    *tree,
6928                                  GtkRBNode    *node)
6929 {
6930   gint retval = FALSE;
6931   do
6932     {
6933       g_return_val_if_fail (node != NULL, FALSE);
6934
6935       if (node->children)
6936         {
6937           GtkTreeIter child;
6938           GtkRBTree *new_tree;
6939           GtkRBNode *new_node;
6940
6941           new_tree = node->children;
6942           new_node = new_tree->root;
6943
6944           while (new_node && new_node->left != new_tree->nil)
6945             new_node = new_node->left;
6946
6947           if (!gtk_tree_model_iter_children (model, &child, iter))
6948             return FALSE;
6949
6950           retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
6951         }
6952
6953       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
6954         retval = TRUE;
6955       gtk_tree_model_unref_node (model, iter);
6956       node = _gtk_rbtree_next (tree, node);
6957     }
6958   while (gtk_tree_model_iter_next (model, iter));
6959
6960   return retval;
6961 }
6962
6963 static gint
6964 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
6965                                               GtkRBTree   *tree)
6966 {
6967   GtkTreeIter iter;
6968   GtkTreePath *path;
6969   GtkRBNode *node;
6970   gint retval;
6971
6972   if (!tree)
6973     return FALSE;
6974
6975   node = tree->root;
6976   while (node && node->left != tree->nil)
6977     node = node->left;
6978
6979   g_return_val_if_fail (node != NULL, FALSE);
6980   path = _gtk_tree_view_find_path (tree_view, tree, node);
6981   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
6982                            &iter, path);
6983   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
6984   gtk_tree_path_free (path);
6985
6986   return retval;
6987 }
6988
6989 static void
6990 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
6991                                     GtkTreeViewColumn *column)
6992 {
6993   GtkTreeViewColumn *left_column;
6994   GtkTreeViewColumn *cur_column = NULL;
6995   GtkTreeViewColumnReorder *reorder;
6996   gboolean rtl;
6997   GList *tmp_list;
6998   gint left;
6999
7000   /* We want to precalculate the motion list such that we know what column slots
7001    * are available.
7002    */
7003   left_column = NULL;
7004   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
7005
7006   /* First, identify all possible drop spots */
7007   if (rtl)
7008     tmp_list = g_list_last (tree_view->priv->columns);
7009   else
7010     tmp_list = g_list_first (tree_view->priv->columns);
7011
7012   while (tmp_list)
7013     {
7014       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
7015       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
7016
7017       if (cur_column->visible == FALSE)
7018         continue;
7019
7020       /* If it's not the column moving and func tells us to skip over the column, we continue. */
7021       if (left_column != column && cur_column != column &&
7022           tree_view->priv->column_drop_func &&
7023           ! (* tree_view->priv->column_drop_func) (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
7024         {
7025           left_column = cur_column;
7026           continue;
7027         }
7028       reorder = g_new (GtkTreeViewColumnReorder, 1);
7029       reorder->left_column = left_column;
7030       left_column = reorder->right_column = cur_column;
7031
7032       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
7033     }
7034
7035   /* Add the last one */
7036   if (tree_view->priv->column_drop_func == NULL ||
7037       ((left_column != column) &&
7038        (* tree_view->priv->column_drop_func) (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data)))
7039     {
7040       reorder = g_new (GtkTreeViewColumnReorder, 1);
7041       reorder->left_column = left_column;
7042       reorder->right_column = NULL;
7043       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
7044     }
7045
7046   /* We quickly check to see if it even makes sense to reorder columns. */
7047   /* If there is nothing that can be moved, then we return */
7048
7049   if (tree_view->priv->column_drag_info == NULL)
7050     return;
7051
7052   /* We know there are always 2 slots possbile, as you can always return column. */
7053   /* If that's all there is, return */
7054   if (tree_view->priv->column_drag_info->next->next == NULL &&
7055       ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
7056       ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column)
7057     {
7058       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
7059         g_free (tmp_list->data);
7060       g_list_free (tree_view->priv->column_drag_info);
7061       tree_view->priv->column_drag_info = NULL;
7062       return;
7063     }
7064   /* We fill in the ranges for the columns, now that we've isolated them */
7065   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
7066
7067   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
7068     {
7069       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
7070
7071       reorder->left_align = left;
7072       if (tmp_list->next != NULL)
7073         {
7074           g_assert (tmp_list->next->data);
7075           left = reorder->right_align = (reorder->right_column->button->allocation.x +
7076                                          reorder->right_column->button->allocation.width +
7077                                          ((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column->button->allocation.x)/2;
7078         }
7079       else
7080         {
7081           gint width;
7082
7083           gdk_drawable_get_size (tree_view->priv->header_window, &width, NULL);
7084           reorder->right_align = width + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
7085         }
7086     }
7087 }
7088
7089 void
7090 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
7091                                   GtkTreeViewColumn *column)
7092 {
7093   GdkEvent *send_event;
7094   GtkAllocation allocation;
7095   gint x, y, width, height;
7096   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
7097   GdkDisplay *display = gdk_screen_get_display (screen);
7098
7099   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
7100
7101   gtk_tree_view_set_column_drag_info (tree_view, column);
7102
7103   if (tree_view->priv->column_drag_info == NULL)
7104     return;
7105
7106   if (tree_view->priv->drag_window == NULL)
7107     {
7108       GdkWindowAttr attributes;
7109       guint attributes_mask;
7110
7111       attributes.window_type = GDK_WINDOW_CHILD;
7112       attributes.wclass = GDK_INPUT_OUTPUT;
7113       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
7114       attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
7115       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
7116       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
7117
7118       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
7119                                                      &attributes,
7120                                                      attributes_mask);
7121       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
7122     }
7123
7124   gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
7125   gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
7126
7127   gtk_grab_remove (column->button);
7128
7129   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
7130   send_event->crossing.send_event = TRUE;
7131   send_event->crossing.window = g_object_ref (column->button->window);
7132   send_event->crossing.subwindow = NULL;
7133   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
7134   send_event->crossing.time = GDK_CURRENT_TIME;
7135
7136   gtk_propagate_event (column->button, send_event);
7137   gdk_event_free (send_event);
7138
7139   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
7140   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
7141   send_event->button.send_event = TRUE;
7142   send_event->button.time = GDK_CURRENT_TIME;
7143   send_event->button.x = -1;
7144   send_event->button.y = -1;
7145   send_event->button.axes = NULL;
7146   send_event->button.state = 0;
7147   send_event->button.button = 1;
7148   send_event->button.device = gdk_display_get_core_pointer (display);
7149   send_event->button.x_root = 0;
7150   send_event->button.y_root = 0;
7151
7152   gtk_propagate_event (column->button, send_event);
7153   gdk_event_free (send_event);
7154
7155   gdk_window_move_resize (tree_view->priv->drag_window,
7156                           column->button->allocation.x,
7157                           0,
7158                           column->button->allocation.width,
7159                           column->button->allocation.height);
7160
7161   /* Kids, don't try this at home */
7162   g_object_ref (column->button);
7163   gtk_container_remove (GTK_CONTAINER (tree_view), column->button);
7164   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
7165   gtk_widget_set_parent (column->button, GTK_WIDGET (tree_view));
7166   g_object_unref (column->button);
7167
7168   tree_view->priv->drag_column_x = column->button->allocation.x;
7169   allocation = column->button->allocation;
7170   allocation.x = 0;
7171   gtk_widget_size_allocate (column->button, &allocation);
7172   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
7173
7174   tree_view->priv->drag_column = column;
7175   gdk_window_show (tree_view->priv->drag_window);
7176
7177   gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
7178   gdk_drawable_get_size (tree_view->priv->header_window, &width, &height);
7179
7180   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7181   while (gtk_events_pending ())
7182     gtk_main_iteration ();
7183
7184   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG);
7185   gdk_pointer_grab (tree_view->priv->drag_window,
7186                     FALSE,
7187                     GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
7188                     NULL, NULL, GDK_CURRENT_TIME);
7189   gdk_keyboard_grab (tree_view->priv->drag_window,
7190                      FALSE,
7191                      GDK_CURRENT_TIME);
7192
7193 }
7194
7195 static void
7196 gtk_tree_view_queue_draw_arrow (GtkTreeView      *tree_view,
7197                                 GtkRBTree        *tree,
7198                                 GtkRBNode        *node,
7199                                 GdkRectangle     *clip_rect)
7200 {
7201   GdkRectangle rect;
7202
7203   if (!GTK_WIDGET_REALIZED (tree_view))
7204     return;
7205
7206   rect.x = 0;
7207   rect.width = MAX (tree_view->priv->expander_size, GTK_WIDGET (tree_view)->allocation.width);
7208
7209   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
7210   rect.height = MAX (BACKGROUND_HEIGHT (node), tree_view->priv->expander_size);
7211
7212   if (clip_rect)
7213     {
7214       GdkRectangle new_rect;
7215
7216       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
7217
7218       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
7219     }
7220   else
7221     {
7222       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
7223     }
7224 }
7225
7226 void
7227 _gtk_tree_view_queue_draw_node (GtkTreeView  *tree_view,
7228                                 GtkRBTree    *tree,
7229                                 GtkRBNode    *node,
7230                                 GdkRectangle *clip_rect)
7231 {
7232   GdkRectangle rect;
7233
7234   if (!GTK_WIDGET_REALIZED (tree_view))
7235     return;
7236
7237   rect.x = 0;
7238   rect.width = MAX (tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width);
7239
7240   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
7241   rect.height = MAX (BACKGROUND_HEIGHT (node), tree_view->priv->expander_size);
7242
7243   if (clip_rect)
7244     {
7245       GdkRectangle new_rect;
7246
7247       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
7248
7249       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
7250     }
7251   else
7252     {
7253       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
7254     }
7255 }
7256
7257 static void
7258 gtk_tree_view_queue_draw_path (GtkTreeView      *tree_view,
7259                                GtkTreePath      *path,
7260                                GdkRectangle     *clip_rect)
7261 {
7262   GtkRBTree *tree = NULL;
7263   GtkRBNode *node = NULL;
7264
7265   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
7266
7267   if (tree)
7268     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
7269 }
7270
7271 /* x and y are the mouse position
7272  */
7273 static void
7274 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
7275                           GtkRBTree   *tree,
7276                           GtkRBNode   *node,
7277                           gint         x,
7278                           gint         y)
7279 {
7280   GdkRectangle area;
7281   GtkStateType state;
7282   GtkWidget *widget;
7283   gint x_offset = 0;
7284   gint vertical_separator;
7285   gint expander_size;
7286   GtkExpanderStyle expander_style;
7287
7288   gtk_widget_style_get (GTK_WIDGET (tree_view),
7289                         "vertical_separator", &vertical_separator,
7290                         NULL);
7291   expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
7292
7293   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
7294     return;
7295
7296   widget = GTK_WIDGET (tree_view);
7297
7298   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, NULL);
7299
7300   area.x = x_offset;
7301   area.y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
7302   area.width = expander_size + 2;
7303   area.height = MAX (CELL_HEIGHT (node, vertical_separator), (expander_size - vertical_separator));
7304
7305   if (node == tree_view->priv->button_pressed_node)
7306     {
7307       if (x >= area.x && x <= (area.x + area.width) &&
7308           y >= area.y && y <= (area.y + area.height))
7309         state = GTK_STATE_ACTIVE;
7310       else
7311         state = GTK_STATE_NORMAL;
7312     }
7313   else
7314     {
7315       if (node == tree_view->priv->prelight_node &&
7316           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
7317         state = GTK_STATE_PRELIGHT;
7318       else
7319         state = GTK_STATE_NORMAL;
7320     }
7321
7322   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
7323     expander_style = GTK_EXPANDER_SEMI_EXPANDED;
7324   else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
7325     expander_style = GTK_EXPANDER_SEMI_COLLAPSED;
7326   else if (node->children != NULL)
7327     expander_style = GTK_EXPANDER_EXPANDED;
7328   else
7329     expander_style = GTK_EXPANDER_COLLAPSED;
7330
7331   gtk_paint_expander (widget->style,
7332                       tree_view->priv->bin_window,
7333                       state,
7334                       &area,
7335                       widget,
7336                       "treeview",
7337                       area.x + area.width / 2,
7338                       area.y + area.height / 2,
7339                       expander_style);
7340 }
7341
7342 static void
7343 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
7344
7345 {
7346   GtkTreePath *cursor_path;
7347
7348   if ((tree_view->priv->tree == NULL) ||
7349       (! GTK_WIDGET_REALIZED (tree_view)))
7350     return;
7351
7352   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
7353
7354   cursor_path = NULL;
7355   if (tree_view->priv->cursor)
7356     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7357
7358   if (cursor_path == NULL)
7359     {
7360       cursor_path = gtk_tree_path_new_first ();
7361       gtk_tree_row_reference_free (tree_view->priv->cursor);
7362       tree_view->priv->cursor = NULL;
7363
7364       if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE)
7365         gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE);
7366       else
7367         gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
7368     }
7369   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
7370   gtk_tree_path_free (cursor_path);
7371
7372   if (tree_view->priv->focus_column == NULL)
7373     {
7374       GList *list;
7375       for (list = tree_view->priv->columns; list; list = list->next)
7376         {
7377           if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
7378             {
7379               tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
7380               break;
7381             }
7382         }
7383     }
7384 }
7385
7386 static void
7387 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
7388                                    gint         count)
7389 {
7390   GtkRBTree *cursor_tree = NULL;
7391   GtkRBNode *cursor_node = NULL;
7392   GtkRBTree *new_cursor_tree = NULL;
7393   GtkRBNode *new_cursor_node = NULL;
7394   GtkTreePath *cursor_path = NULL;
7395
7396   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
7397     return;
7398
7399   cursor_path = NULL;
7400   if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
7401     /* FIXME: we lost the cursor; should we get the first? */
7402     return;
7403
7404   cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7405   _gtk_tree_view_find_node (tree_view, cursor_path,
7406                             &cursor_tree, &cursor_node);
7407   gtk_tree_path_free (cursor_path);
7408
7409   if (cursor_tree == NULL)
7410     /* FIXME: we lost the cursor; should we get the first? */
7411     return;
7412   if (count == -1)
7413     _gtk_rbtree_prev_full (cursor_tree, cursor_node,
7414                            &new_cursor_tree, &new_cursor_node);
7415   else
7416     _gtk_rbtree_next_full (cursor_tree, cursor_node,
7417                            &new_cursor_tree, &new_cursor_node);
7418
7419   if (new_cursor_node)
7420     {
7421       cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node);
7422       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
7423       gtk_tree_path_free (cursor_path);
7424     }
7425   else
7426     {
7427       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
7428     }
7429
7430   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7431 }
7432
7433 static void
7434 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
7435                                         gint         count)
7436 {
7437   GtkRBTree *cursor_tree = NULL;
7438   GtkRBNode *cursor_node = NULL;
7439   GtkTreePath *cursor_path = NULL;
7440   gint y;
7441   gint vertical_separator;
7442
7443   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
7444     return;
7445
7446   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
7447     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7448   else
7449     /* This is sorta weird.  Focus in should give us a cursor */
7450     return;
7451
7452   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical_separator", &vertical_separator, NULL);
7453   _gtk_tree_view_find_node (tree_view, cursor_path,
7454                             &cursor_tree, &cursor_node);
7455
7456   gtk_tree_path_free (cursor_path);
7457
7458   if (cursor_tree == NULL)
7459     /* FIXME: we lost the cursor.  Should we try to get one? */
7460     return;
7461   g_return_if_fail (cursor_node != NULL);
7462
7463   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
7464   y += count * tree_view->priv->vadjustment->page_size;
7465   if (count > 0)
7466     y -= MAX (GTK_RBNODE_GET_HEIGHT (cursor_node),
7467               tree_view->priv->expander_size);
7468   else if (count < 0)
7469     y += MAX (GTK_RBNODE_GET_HEIGHT (cursor_node),
7470               tree_view->priv->expander_size);
7471   y = CLAMP (y, (gint)tree_view->priv->vadjustment->lower,  (gint)tree_view->priv->vadjustment->upper - vertical_separator);
7472
7473   if (y > tree_view->priv->height)
7474     y = tree_view->priv->height - 1;
7475
7476   _gtk_rbtree_find_offset (tree_view->priv->tree, y, &cursor_tree, &cursor_node);
7477   cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
7478   g_return_if_fail (cursor_path != NULL);
7479   gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
7480   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
7481   gtk_tree_path_free (cursor_path);
7482 }
7483
7484 static void
7485 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
7486                                       gint         count)
7487 {
7488   GtkRBTree *cursor_tree = NULL;
7489   GtkRBNode *cursor_node = NULL;
7490   GtkTreePath *cursor_path = NULL;
7491   GtkTreeViewColumn *column;
7492   GtkTreeIter iter;
7493   GList *list;
7494   gboolean found_column = FALSE;
7495   gboolean rtl;
7496
7497   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
7498
7499   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
7500     return;
7501
7502   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
7503     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7504   else
7505     return;
7506
7507   _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node);
7508   if (cursor_tree == NULL)
7509     return;
7510   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
7511     {
7512       gtk_tree_path_free (cursor_path);
7513       return;
7514     }
7515   gtk_tree_path_free (cursor_path);
7516
7517   list = tree_view->priv->columns;
7518   if (tree_view->priv->focus_column)
7519     {
7520       for (list = tree_view->priv->columns; list; list = list->next)
7521         {
7522           if (list->data == tree_view->priv->focus_column)
7523             break;
7524         }
7525     }
7526
7527   while (list)
7528     {
7529       column = list->data;
7530       if (column->visible == FALSE)
7531         goto loop_end;
7532
7533       gtk_tree_view_column_cell_set_cell_data (column,
7534                                                tree_view->priv->model,
7535                                                &iter,
7536                                                GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
7537                                                cursor_node->children?TRUE:FALSE);
7538       if (_gtk_tree_view_column_cell_focus (column, count,
7539                                             list->prev?TRUE:FALSE,
7540                                             list->next?TRUE:FALSE))
7541         {
7542           tree_view->priv->focus_column = column;
7543           found_column = TRUE;
7544           break;
7545         }
7546     loop_end:
7547       if (count == 1)
7548         list = rtl ? list->prev : list->next;
7549       else
7550         list = rtl ? list->next : list->prev;
7551     }
7552
7553   if (found_column)
7554     {
7555       if (!gtk_tree_view_has_special_cell (tree_view))
7556         _gtk_tree_view_queue_draw_node (tree_view,
7557                                         cursor_tree,
7558                                         cursor_node,
7559                                         NULL);
7560       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
7561     }
7562   gtk_tree_view_clamp_column_visible (tree_view, tree_view->priv->focus_column);
7563 }
7564
7565 static void
7566 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
7567                                      gint         count)
7568 {
7569   GtkRBTree *cursor_tree;
7570   GtkRBNode *cursor_node;
7571   GtkTreePath *path;
7572
7573   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
7574     return;
7575
7576   g_return_if_fail (tree_view->priv->tree != NULL);
7577
7578   if (count == -1)
7579     {
7580       cursor_tree = tree_view->priv->tree;
7581       cursor_node = cursor_tree->root;
7582       while (cursor_node && cursor_node->left != cursor_tree->nil)
7583         cursor_node = cursor_node->left;
7584     }
7585   else
7586     {
7587       cursor_tree = tree_view->priv->tree;
7588       cursor_node = cursor_tree->root;
7589       do
7590         {
7591           while (cursor_node && cursor_node->right != cursor_tree->nil)
7592             cursor_node = cursor_node->right;
7593           if (cursor_node->children == NULL)
7594             break;
7595
7596           cursor_tree = cursor_node->children;
7597           cursor_node = cursor_tree->root;
7598         }
7599       while (1);
7600     }
7601
7602   path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
7603   gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
7604   gtk_tree_path_free (path);
7605 }
7606
7607 static gboolean
7608 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
7609 {
7610   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
7611     return FALSE;
7612
7613   if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
7614     return FALSE;
7615
7616   gtk_tree_selection_select_all (tree_view->priv->selection);
7617
7618   return TRUE;
7619 }
7620
7621 static gboolean
7622 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
7623 {
7624   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
7625     return FALSE;
7626
7627   if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
7628     return FALSE;
7629
7630   gtk_tree_selection_unselect_all (tree_view->priv->selection);
7631
7632   return TRUE;
7633 }
7634
7635 static gboolean
7636 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
7637                                       gboolean     start_editing)
7638 {
7639   GtkRBTree *cursor_tree = NULL;
7640   GtkRBNode *cursor_node = NULL;
7641   GtkTreePath *cursor_path = NULL;
7642   GdkModifierType state = 0;
7643   cursor_path = NULL;
7644
7645   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
7646     return FALSE;
7647
7648   if (tree_view->priv->cursor)
7649     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7650
7651   if (cursor_path == NULL)
7652     return FALSE;
7653
7654   _gtk_tree_view_find_node (tree_view, cursor_path,
7655                             &cursor_tree, &cursor_node);
7656
7657   if (cursor_tree == NULL)
7658     {
7659       gtk_tree_path_free (cursor_path);
7660       return FALSE;
7661     }
7662
7663   gtk_get_current_event_state (&state);
7664
7665   if (! (state & GDK_SHIFT_MASK) &&
7666       start_editing &&
7667       tree_view->priv->focus_column)
7668     {
7669       if (gtk_tree_view_start_editing (tree_view, cursor_path))
7670         {
7671           gtk_tree_path_free (cursor_path);
7672           return TRUE;
7673         }
7674     }
7675   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
7676                                             cursor_node,
7677                                             cursor_tree,
7678                                             cursor_path,
7679                                             state,
7680                                             FALSE);
7681
7682   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
7683
7684   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7685   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
7686
7687   if (! (state & GDK_SHIFT_MASK))
7688     gtk_tree_view_row_activated (tree_view, cursor_path, tree_view->priv->focus_column);
7689
7690   gtk_tree_path_free (cursor_path);
7691
7692   return TRUE;
7693 }
7694
7695 static gboolean
7696 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
7697 {
7698   GtkRBTree *cursor_tree = NULL;
7699   GtkRBNode *cursor_node = NULL;
7700   GtkTreePath *cursor_path = NULL;
7701
7702   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
7703     return FALSE;
7704
7705   cursor_path = NULL;
7706   if (tree_view->priv->cursor)
7707     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7708
7709   if (cursor_path == NULL)
7710     return FALSE;
7711
7712   _gtk_tree_view_find_node (tree_view, cursor_path,
7713                             &cursor_tree, &cursor_node);
7714   if (cursor_tree == NULL)
7715     {
7716       gtk_tree_path_free (cursor_path);
7717       return FALSE;
7718     }
7719
7720   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
7721                                             cursor_node,
7722                                             cursor_tree,
7723                                             cursor_path,
7724                                             GDK_CONTROL_MASK,
7725                                             FALSE);
7726
7727   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
7728
7729   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7730   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
7731   gtk_tree_path_free (cursor_path);
7732
7733   return TRUE;
7734 }
7735
7736 static gboolean
7737 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
7738                                                gboolean     logical,
7739                                                gboolean     expand,
7740                                                gboolean     open_all)
7741 {
7742   GtkTreePath *cursor_path = NULL;
7743   GtkRBTree *tree;
7744   GtkRBNode *node;
7745
7746   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
7747     return FALSE;
7748
7749   cursor_path = NULL;
7750   if (tree_view->priv->cursor)
7751     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7752
7753   if (cursor_path == NULL)
7754     return FALSE;
7755
7756   if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node))
7757     return FALSE;
7758
7759   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7760   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
7761
7762   if (expand)
7763     gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE);
7764   else
7765     gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE);
7766
7767   gtk_tree_path_free (cursor_path);
7768
7769   return TRUE;
7770 }
7771
7772 static gboolean
7773 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
7774 {
7775   GtkRBTree *cursor_tree = NULL;
7776   GtkRBNode *cursor_node = NULL;
7777   GtkTreePath *cursor_path = NULL;
7778
7779   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
7780     return FALSE;
7781
7782   cursor_path = NULL;
7783   if (tree_view->priv->cursor)
7784     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7785
7786   if (cursor_path == NULL)
7787     return FALSE;
7788
7789   _gtk_tree_view_find_node (tree_view, cursor_path,
7790                             &cursor_tree, &cursor_node);
7791   if (cursor_tree == NULL)
7792     {
7793       gtk_tree_path_free (cursor_path);
7794       return FALSE;
7795     }
7796
7797   if (cursor_tree->parent_node)
7798     {
7799       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
7800       cursor_node = cursor_tree->parent_node;
7801       cursor_tree = cursor_tree->parent_tree;
7802
7803       gtk_tree_path_up (cursor_path);
7804       gtk_tree_row_reference_free (tree_view->priv->cursor);
7805       tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, cursor_path);
7806       _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
7807                                                 cursor_node,
7808                                                 cursor_tree,
7809                                                 cursor_path,
7810                                                 0,
7811                                                 FALSE);
7812     }
7813
7814   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
7815
7816   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7817   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
7818   gtk_tree_path_free (cursor_path);
7819
7820   return TRUE;
7821 }
7822
7823 /* Cut and paste from gtkwindow.c */
7824 static void
7825 send_focus_change (GtkWidget *widget,
7826                    gboolean   in)
7827 {
7828   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
7829
7830   g_object_ref (widget);
7831
7832  if (in)
7833     GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
7834   else
7835     GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
7836
7837   fevent->focus_change.type = GDK_FOCUS_CHANGE;
7838   fevent->focus_change.window = g_object_ref (widget->window);
7839   fevent->focus_change.in = in;
7840
7841   gtk_widget_event (widget, fevent);
7842
7843   g_object_notify (G_OBJECT (widget), "has_focus");
7844
7845   g_object_unref (widget);
7846   gdk_event_free (fevent);
7847 }
7848
7849 static gboolean
7850 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view)
7851 {
7852   GtkWidget *window;
7853   GtkWidget *entry;
7854   GtkWidget *search_dialog;
7855
7856   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
7857     return FALSE;
7858
7859   if (tree_view->priv->enable_search == FALSE ||
7860       tree_view->priv->search_column < 0)
7861     return FALSE;
7862
7863   search_dialog = g_object_get_data (G_OBJECT (tree_view),
7864                                      GTK_TREE_VIEW_SEARCH_DIALOG_KEY);
7865   if (search_dialog)
7866     return FALSE;
7867
7868   /* set up window */
7869   window = gtk_window_new (GTK_WINDOW_POPUP);
7870   gtk_window_set_title (GTK_WINDOW (window), "search dialog");
7871   gtk_container_set_border_width (GTK_CONTAINER (window), 3);
7872   gtk_window_set_modal (GTK_WINDOW (window), TRUE);
7873   g_signal_connect (window, "delete_event",
7874                     G_CALLBACK (gtk_tree_view_search_delete_event),
7875                     tree_view);
7876   g_signal_connect (window, "key_press_event",
7877                     G_CALLBACK (gtk_tree_view_search_key_press_event),
7878                     tree_view);
7879   g_signal_connect (window, "button_press_event",
7880                     G_CALLBACK (gtk_tree_view_search_button_press_event),
7881                     tree_view);
7882
7883   /* add entry */
7884   entry = gtk_entry_new ();
7885   gtk_widget_show (entry);
7886   g_signal_connect (entry, "changed",
7887                     G_CALLBACK (gtk_tree_view_search_init),
7888                     tree_view);
7889   g_signal_connect (entry, "populate_popup",
7890                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
7891                     tree_view);
7892   gtk_container_add (GTK_CONTAINER (window), entry);
7893
7894   /* done, show it */
7895   tree_view->priv->search_dialog_position_func (tree_view, window);
7896   gtk_widget_show_all (window);
7897   gtk_widget_grab_focus (entry);
7898
7899   /* send focus-in event */
7900   send_focus_change (entry, TRUE);
7901
7902   /* position window */
7903
7904   /* yes, we point to the entry's private text thing here, a bit evil */
7905   g_object_set_data (G_OBJECT (window), "gtk-tree-view-text",
7906                      (gchar *) gtk_entry_get_text (GTK_ENTRY (entry)));
7907   g_object_set_data (G_OBJECT (tree_view),
7908                      GTK_TREE_VIEW_SEARCH_DIALOG_KEY, window);
7909
7910   /* search first matching iter */
7911   gtk_tree_view_search_init (entry, tree_view);
7912
7913   return TRUE;
7914 }
7915
7916 /* this function returns the new width of the column being resized given
7917  * the column and x position of the cursor; the x cursor position is passed
7918  * in as a pointer and automagicly corrected if it's beyond min/max limits
7919  */
7920 static gint
7921 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
7922                                 gint       i,
7923                                 gint      *x)
7924 {
7925   GtkTreeViewColumn *column;
7926   gint width;
7927
7928   /* first translate the x position from widget->window
7929    * to clist->clist_window
7930    */
7931
7932   column = g_list_nth (tree_view->priv->columns, i)->data;
7933   width = *x - column->button->allocation.x;
7934
7935   /* Clamp down the value */
7936   if (column->min_width == -1)
7937     width = MAX (column->button->requisition.width,
7938                  width);
7939   else
7940     width = MAX (column->min_width,
7941                  width);
7942   if (column->max_width != -1)
7943     width = MIN (width, column->max_width != -1);
7944   *x = column->button->allocation.x + width;
7945
7946   return width;
7947 }
7948
7949
7950 /* Callbacks */
7951 static void
7952 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
7953                                   GtkTreeView   *tree_view)
7954 {
7955   if (GTK_WIDGET_REALIZED (tree_view))
7956     {
7957       gint dy;
7958
7959       gdk_window_move (tree_view->priv->bin_window,
7960                        - tree_view->priv->hadjustment->value,
7961                        TREE_VIEW_HEADER_HEIGHT (tree_view));
7962       gdk_window_move (tree_view->priv->header_window,
7963                        - tree_view->priv->hadjustment->value,
7964                        0);
7965       dy = tree_view->priv->dy - (int) tree_view->priv->vadjustment->value;
7966       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
7967
7968       /* update our dy and top_row */
7969       tree_view->priv->dy = (int) tree_view->priv->vadjustment->value;
7970       gtk_tree_view_dy_to_top_row (tree_view);
7971     }
7972 }
7973
7974 \f
7975
7976 /* Public methods
7977  */
7978
7979 /**
7980  * gtk_tree_view_new:
7981  *
7982  * Creates a new #GtkTreeView widget.
7983  *
7984  * Return value: A newly created #GtkTreeView widget.
7985  **/
7986 GtkWidget *
7987 gtk_tree_view_new (void)
7988 {
7989   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
7990 }
7991
7992 /**
7993  * gtk_tree_view_new_with_model:
7994  * @model: the model.
7995  *
7996  * Creates a new #GtkTreeView widget with the model initialized to @model.
7997  *
7998  * Return value: A newly created #GtkTreeView widget.
7999  **/
8000 GtkWidget *
8001 gtk_tree_view_new_with_model (GtkTreeModel *model)
8002 {
8003   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
8004 }
8005
8006 /* Public Accessors
8007  */
8008
8009 /**
8010  * gtk_tree_view_get_model:
8011  * @tree_view: a #GtkTreeView
8012  *
8013  * Returns the model the the #GtkTreeView is based on.  Returns %NULL if the
8014  * model is unset.
8015  *
8016  * Return value: A #GtkTreeModel, or %NULL if none is currently being used.
8017  **/
8018 GtkTreeModel *
8019 gtk_tree_view_get_model (GtkTreeView *tree_view)
8020 {
8021   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
8022
8023   return tree_view->priv->model;
8024 }
8025
8026 /**
8027  * gtk_tree_view_set_model:
8028  * @tree_view: A #GtkTreeNode.
8029  * @model: The model.
8030  *
8031  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
8032  * set, it will remove it before setting the new model.  If @model is %NULL, then
8033  * it will unset the old model.
8034  **/
8035 void
8036 gtk_tree_view_set_model (GtkTreeView  *tree_view,
8037                          GtkTreeModel *model)
8038 {
8039   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8040
8041   if (model == tree_view->priv->model)
8042     return;
8043
8044   if (tree_view->priv->model)
8045     {
8046       GList *tmplist = tree_view->priv->columns;
8047
8048       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
8049
8050       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
8051                                             gtk_tree_view_row_changed,
8052                                             tree_view);
8053       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
8054                                             gtk_tree_view_row_inserted,
8055                                             tree_view);
8056       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
8057                                             gtk_tree_view_row_has_child_toggled,
8058                                             tree_view);
8059       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
8060                                             gtk_tree_view_row_deleted,
8061                                             tree_view);
8062       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
8063                                             gtk_tree_view_rows_reordered,
8064                                             tree_view);
8065
8066       for (; tmplist; tmplist = tmplist->next)
8067         _gtk_tree_view_column_unset_model (tmplist->data,
8068                                            tree_view->priv->model);
8069
8070       if (tree_view->priv->tree)
8071         {
8072           _gtk_rbtree_free (tree_view->priv->tree);
8073           tree_view->priv->tree = NULL;
8074         }
8075
8076       tree_view->priv->prelight_node = NULL;
8077       tree_view->priv->prelight_tree = NULL;
8078       tree_view->priv->button_pressed_node = NULL;
8079       tree_view->priv->button_pressed_tree = NULL;
8080
8081       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
8082       tree_view->priv->drag_dest_row = NULL;
8083       gtk_tree_row_reference_free (tree_view->priv->cursor);
8084       tree_view->priv->cursor = NULL;
8085       gtk_tree_row_reference_free (tree_view->priv->anchor);
8086       tree_view->priv->anchor = NULL;
8087
8088       g_object_unref (tree_view->priv->model);
8089       tree_view->priv->search_column = -1;
8090       GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
8091       tree_view->priv->fixed_height_check = 0;
8092     }
8093
8094   tree_view->priv->model = model;
8095
8096
8097   if (tree_view->priv->model)
8098     {
8099       gint i;
8100       GtkTreePath *path;
8101       GtkTreeIter iter;
8102
8103       if (tree_view->priv->search_column == -1)
8104         {
8105           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
8106             {
8107               GType type = gtk_tree_model_get_column_type (model, i);
8108
8109               if (g_value_type_transformable (type, G_TYPE_STRING))
8110                 {
8111                   tree_view->priv->search_column = i;
8112                   break;
8113                 }
8114             }
8115         }
8116
8117       g_object_ref (tree_view->priv->model);
8118       g_signal_connect (tree_view->priv->model,
8119                         "row_changed",
8120                         G_CALLBACK (gtk_tree_view_row_changed),
8121                         tree_view);
8122       g_signal_connect (tree_view->priv->model,
8123                         "row_inserted",
8124                         G_CALLBACK (gtk_tree_view_row_inserted),
8125                         tree_view);
8126       g_signal_connect (tree_view->priv->model,
8127                         "row_has_child_toggled",
8128                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
8129                         tree_view);
8130       g_signal_connect (tree_view->priv->model,
8131                         "row_deleted",
8132                         G_CALLBACK (gtk_tree_view_row_deleted),
8133                         tree_view);
8134       g_signal_connect (tree_view->priv->model,
8135                         "rows_reordered",
8136                         G_CALLBACK (gtk_tree_view_rows_reordered),
8137                         tree_view);
8138
8139       path = gtk_tree_path_new_first ();
8140       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
8141         {
8142           tree_view->priv->tree = _gtk_rbtree_new ();
8143           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
8144         }
8145       gtk_tree_path_free (path);
8146
8147       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
8148       install_presize_handler (tree_view);
8149     }
8150
8151   g_object_notify (G_OBJECT (tree_view), "model");
8152
8153   if (GTK_WIDGET_REALIZED (tree_view))
8154     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8155 }
8156
8157 /**
8158  * gtk_tree_view_get_selection:
8159  * @tree_view: A #GtkTreeView.
8160  *
8161  * Gets the #GtkTreeSelection associated with @tree_view.
8162  *
8163  * Return value: A #GtkTreeSelection object.
8164  **/
8165 GtkTreeSelection *
8166 gtk_tree_view_get_selection (GtkTreeView *tree_view)
8167 {
8168   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
8169
8170   return tree_view->priv->selection;
8171 }
8172
8173 /**
8174  * gtk_tree_view_get_hadjustment:
8175  * @tree_view: A #GtkTreeView
8176  *
8177  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
8178  *
8179  * Return value: A #GtkAdjustment object, or %NULL if none is currently being
8180  * used.
8181  **/
8182 GtkAdjustment *
8183 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
8184 {
8185   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
8186
8187   if (tree_view->priv->hadjustment == NULL)
8188     gtk_tree_view_set_hadjustment (tree_view, NULL);
8189
8190   return tree_view->priv->hadjustment;
8191 }
8192
8193 /**
8194  * gtk_tree_view_set_hadjustment:
8195  * @tree_view: A #GtkTreeView
8196  * @adjustment: The #GtkAdjustment to set, or %NULL
8197  *
8198  * Sets the #GtkAdjustment for the current horizontal aspect.
8199  **/
8200 void
8201 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
8202                                GtkAdjustment *adjustment)
8203 {
8204   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8205
8206   gtk_tree_view_set_adjustments (tree_view,
8207                                  adjustment,
8208                                  tree_view->priv->vadjustment);
8209
8210   g_object_notify (G_OBJECT (tree_view), "hadjustment");
8211 }
8212
8213 /**
8214  * gtk_tree_view_get_vadjustment:
8215  * @tree_view: A #GtkTreeView
8216  *
8217  * Gets the #GtkAdjustment currently being used for the vertical aspect.
8218  *
8219  * Return value: A #GtkAdjustment object, or %NULL if none is currently being
8220  * used.
8221  **/
8222 GtkAdjustment *
8223 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
8224 {
8225   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
8226
8227   if (tree_view->priv->vadjustment == NULL)
8228     gtk_tree_view_set_vadjustment (tree_view, NULL);
8229
8230   return tree_view->priv->vadjustment;
8231 }
8232
8233 /**
8234  * gtk_tree_view_set_vadjustment:
8235  * @tree_view: A #GtkTreeView
8236  * @adjustment: The #GtkAdjustment to set, or %NULL
8237  *
8238  * Sets the #GtkAdjustment for the current vertical aspect.
8239  **/
8240 void
8241 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
8242                                GtkAdjustment *adjustment)
8243 {
8244   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8245
8246   gtk_tree_view_set_adjustments (tree_view,
8247                                  tree_view->priv->hadjustment,
8248                                  adjustment);
8249
8250   g_object_notify (G_OBJECT (tree_view), "vadjustment");
8251 }
8252
8253 /* Column and header operations */
8254
8255 /**
8256  * gtk_tree_view_get_headers_visible:
8257  * @tree_view: A #GtkTreeView.
8258  *
8259  * Returns %TRUE if the headers on the @tree_view are visible.
8260  *
8261  * Return value: Whether the headers are visible or not.
8262  **/
8263 gboolean
8264 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
8265 {
8266   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8267
8268   return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
8269 }
8270
8271 /**
8272  * gtk_tree_view_set_headers_visible:
8273  * @tree_view: A #GtkTreeView.
8274  * @headers_visible: %TRUE if the headers are visible
8275  *
8276  * Sets the the visibility state of the headers.
8277  **/
8278 void
8279 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
8280                                    gboolean     headers_visible)
8281 {
8282   gint x, y;
8283   GList *list;
8284   GtkTreeViewColumn *column;
8285
8286   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8287
8288   headers_visible = !! headers_visible;
8289
8290   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE) == headers_visible)
8291     return;
8292
8293   if (headers_visible)
8294     GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
8295   else
8296     GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
8297
8298   if (GTK_WIDGET_REALIZED (tree_view))
8299     {
8300       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
8301       if (headers_visible)
8302         {
8303           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));
8304
8305           if (GTK_WIDGET_MAPPED (tree_view))
8306             gtk_tree_view_map_buttons (tree_view);
8307         }
8308       else
8309         {
8310           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
8311
8312           for (list = tree_view->priv->columns; list; list = list->next)
8313             {
8314               column = list->data;
8315               gtk_widget_unmap (column->button);
8316             }
8317           gdk_window_hide (tree_view->priv->header_window);
8318         }
8319     }
8320
8321   tree_view->priv->vadjustment->page_size = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
8322   tree_view->priv->vadjustment->page_increment = (GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2;
8323   tree_view->priv->vadjustment->lower = 0;
8324   tree_view->priv->vadjustment->upper = tree_view->priv->height;
8325   gtk_adjustment_changed (tree_view->priv->vadjustment);
8326
8327   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8328
8329   g_object_notify (G_OBJECT (tree_view), "headers_visible");
8330 }
8331
8332 /**
8333  * gtk_tree_view_columns_autosize:
8334  * @tree_view: A #GtkTreeView.
8335  *
8336  * Resizes all columns to their optimal width. Only works after the
8337  * treeview has been realized.
8338  **/
8339 void
8340 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
8341 {
8342   gboolean dirty = FALSE;
8343   GList *list;
8344   GtkTreeViewColumn *column;
8345
8346   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8347
8348   for (list = tree_view->priv->columns; list; list = list->next)
8349     {
8350       column = list->data;
8351       if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8352         continue;
8353       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8354       dirty = TRUE;
8355     }
8356
8357   if (dirty)
8358     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8359 }
8360
8361 /**
8362  * gtk_tree_view_set_headers_clickable:
8363  * @tree_view: A #GtkTreeView.
8364  * @setting: %TRUE if the columns are clickable.
8365  *
8366  * Allow the column title buttons to be clicked.
8367  **/
8368 void
8369 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
8370                                      gboolean   setting)
8371 {
8372   GList *list;
8373
8374   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8375   g_return_if_fail (tree_view->priv->model != NULL);
8376
8377   for (list = tree_view->priv->columns; list; list = list->next)
8378     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
8379
8380   g_object_notify (G_OBJECT (tree_view), "headers_clickable");
8381 }
8382
8383
8384 /**
8385  * gtk_tree_view_set_rules_hint
8386  * @tree_view: a #GtkTreeView
8387  * @setting: %TRUE if the tree requires reading across rows
8388  *
8389  * This function tells GTK+ that the user interface for your
8390  * application requires users to read across tree rows and associate
8391  * cells with one another. By default, GTK+ will then render the tree
8392  * with alternating row colors. Do <emphasis>not</emphasis> use it
8393  * just because you prefer the appearance of the ruled tree; that's a
8394  * question for the theme. Some themes will draw tree rows in
8395  * alternating colors even when rules are turned off, and users who
8396  * prefer that appearance all the time can choose those themes. You
8397  * should call this function only as a <emphasis>semantic</emphasis>
8398  * hint to the theme engine that your tree makes alternating colors
8399  * useful from a functional standpoint (since it has lots of columns,
8400  * generally).
8401  *
8402  **/
8403 void
8404 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
8405                               gboolean      setting)
8406 {
8407   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8408
8409   setting = setting != FALSE;
8410
8411   if (tree_view->priv->has_rules != setting)
8412     {
8413       tree_view->priv->has_rules = setting;
8414       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
8415     }
8416
8417   g_object_notify (G_OBJECT (tree_view), "rules_hint");
8418 }
8419
8420 /**
8421  * gtk_tree_view_get_rules_hint
8422  * @tree_view: a #GtkTreeView
8423  *
8424  * Gets the setting set by gtk_tree_view_set_rules_hint().
8425  *
8426  * Return value: %TRUE if rules are useful for the user of this tree
8427  **/
8428 gboolean
8429 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
8430 {
8431   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8432
8433   return tree_view->priv->has_rules;
8434 }
8435
8436 /* Public Column functions
8437  */
8438
8439 /**
8440  * gtk_tree_view_append_column:
8441  * @tree_view: A #GtkTreeView.
8442  * @column: The #GtkTreeViewColumn to add.
8443  *
8444  * Appends @column to the list of columns.
8445  *
8446  * Return value: The number of columns in @tree_view after appending.
8447  **/
8448 gint
8449 gtk_tree_view_append_column (GtkTreeView       *tree_view,
8450                              GtkTreeViewColumn *column)
8451 {
8452   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
8453   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
8454   g_return_val_if_fail (column->tree_view == NULL, -1);
8455
8456   return gtk_tree_view_insert_column (tree_view, column, -1);
8457 }
8458
8459
8460 /**
8461  * gtk_tree_view_remove_column:
8462  * @tree_view: A #GtkTreeView.
8463  * @column: The #GtkTreeViewColumn to remove.
8464  *
8465  * Removes @column from @tree_view.
8466  *
8467  * Return value: The number of columns in @tree_view after removing.
8468  **/
8469 gint
8470 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
8471                              GtkTreeViewColumn *column)
8472 {
8473   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
8474   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
8475   g_return_val_if_fail (column->tree_view == GTK_WIDGET (tree_view), -1);
8476
8477   if (tree_view->priv->focus_column == column)
8478     tree_view->priv->focus_column = NULL;
8479
8480   if (tree_view->priv->edited_column == column)
8481     {
8482       gtk_tree_view_stop_editing (tree_view, TRUE);
8483
8484       /* no need to, but just to be sure ... */
8485       tree_view->priv->edited_column = NULL;
8486     }
8487
8488   _gtk_tree_view_column_unset_tree_view (column);
8489
8490   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
8491   tree_view->priv->n_columns--;
8492
8493   if (GTK_WIDGET_REALIZED (tree_view))
8494     {
8495       GList *list;
8496
8497       _gtk_tree_view_column_unrealize_button (column);
8498       for (list = tree_view->priv->columns; list; list = list->next)
8499         {
8500           GtkTreeViewColumn *tmp_column;
8501
8502           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
8503           if (tmp_column->visible)
8504             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
8505         }
8506
8507       if (tree_view->priv->n_columns == 0 &&
8508           gtk_tree_view_get_headers_visible (tree_view))
8509         gdk_window_hide (tree_view->priv->header_window);
8510
8511       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8512     }
8513
8514   g_object_unref (column);
8515   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
8516
8517   return tree_view->priv->n_columns;
8518 }
8519
8520 /**
8521  * gtk_tree_view_insert_column:
8522  * @tree_view: A #GtkTreeView.
8523  * @column: The #GtkTreeViewColumn to be inserted.
8524  * @position: The position to insert @column in.
8525  *
8526  * This inserts the @column into the @tree_view at @position.  If @position is
8527  * -1, then the column is inserted at the end.
8528  *
8529  * Return value: The number of columns in @tree_view after insertion.
8530  **/
8531 gint
8532 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
8533                              GtkTreeViewColumn *column,
8534                              gint               position)
8535 {
8536   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
8537   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
8538   g_return_val_if_fail (column->tree_view == NULL, -1);
8539
8540   g_object_ref (column);
8541   gtk_object_sink (GTK_OBJECT (column));
8542
8543   if (tree_view->priv->n_columns == 0 &&
8544       GTK_WIDGET_REALIZED (tree_view) &&
8545       gtk_tree_view_get_headers_visible (tree_view))
8546     {
8547       gdk_window_show (tree_view->priv->header_window);
8548     }
8549
8550   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
8551                                             column, position);
8552   tree_view->priv->n_columns++;
8553
8554   _gtk_tree_view_column_set_tree_view (column, tree_view);
8555
8556   if (GTK_WIDGET_REALIZED (tree_view))
8557     {
8558       GList *list;
8559
8560       _gtk_tree_view_column_realize_button (column);
8561
8562       for (list = tree_view->priv->columns; list; list = list->next)
8563         {
8564           column = GTK_TREE_VIEW_COLUMN (list->data);
8565           if (column->visible)
8566             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8567         }
8568       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8569     }
8570
8571   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
8572
8573   return tree_view->priv->n_columns;
8574 }
8575
8576 /**
8577  * gtk_tree_view_insert_column_with_attributes:
8578  * @tree_view: A #GtkTreeView
8579  * @position: The position to insert the new column in.
8580  * @title: The title to set the header to.
8581  * @cell: The #GtkCellRenderer.
8582  * @Varargs: A %NULL-terminated list of attributes.
8583  *
8584  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
8585  * @position.  If @position is -1, then the newly created column is inserted at
8586  * the end.  The column is initialized with the attributes given.
8587  *
8588  * Return value: The number of columns in @tree_view after insertion.
8589  **/
8590 gint
8591 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
8592                                              gint             position,
8593                                              const gchar     *title,
8594                                              GtkCellRenderer *cell,
8595                                              ...)
8596 {
8597   GtkTreeViewColumn *column;
8598   gchar *attribute;
8599   va_list args;
8600   gint column_id;
8601
8602   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
8603
8604   column = gtk_tree_view_column_new ();
8605
8606   gtk_tree_view_column_set_title (column, title);
8607   gtk_tree_view_column_pack_start (column, cell, TRUE);
8608
8609   va_start (args, cell);
8610
8611   attribute = va_arg (args, gchar *);
8612
8613   while (attribute != NULL)
8614     {
8615       column_id = va_arg (args, gint);
8616       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
8617       attribute = va_arg (args, gchar *);
8618     }
8619
8620   va_end (args);
8621
8622   gtk_tree_view_insert_column (tree_view, column, position);
8623
8624   return tree_view->priv->n_columns;
8625 }
8626
8627 /**
8628  * gtk_tree_view_insert_column_with_data_func:
8629  * @tree_view: a #GtkTreeView
8630  * @position: Position to insert, -1 for append
8631  * @title: column title
8632  * @cell: cell renderer for column
8633  * @func: function to set attributes of cell renderer
8634  * @data: data for @func
8635  * @dnotify: destroy notifier for @data
8636  *
8637  * Convenience function that inserts a new column into the #GtkTreeView
8638  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
8639  * attributes (normally using data from the model). See also
8640  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
8641  *
8642  * Return value: number of columns in the tree view post-insert
8643  **/
8644 gint
8645 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
8646                                              gint                       position,
8647                                              const gchar               *title,
8648                                              GtkCellRenderer           *cell,
8649                                              GtkTreeCellDataFunc        func,
8650                                              gpointer                   data,
8651                                              GDestroyNotify             dnotify)
8652 {
8653   GtkTreeViewColumn *column;
8654
8655   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
8656
8657   column = gtk_tree_view_column_new ();
8658
8659   gtk_tree_view_column_set_title (column, title);
8660   gtk_tree_view_column_pack_start (column, cell, TRUE);
8661   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
8662
8663   gtk_tree_view_insert_column (tree_view, column, position);
8664
8665   return tree_view->priv->n_columns;
8666 }
8667
8668 /**
8669  * gtk_tree_view_get_column:
8670  * @tree_view: A #GtkTreeView.
8671  * @n: The position of the column, counting from 0.
8672  *
8673  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
8674  *
8675  * Return value: The #GtkTreeViewColumn, or %NULL if the position is outside the
8676  * range of columns.
8677  **/
8678 GtkTreeViewColumn *
8679 gtk_tree_view_get_column (GtkTreeView *tree_view,
8680                           gint         n)
8681 {
8682   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
8683
8684   if (n < 0 || n >= tree_view->priv->n_columns)
8685     return NULL;
8686
8687   if (tree_view->priv->columns == NULL)
8688     return NULL;
8689
8690   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
8691 }
8692
8693 /**
8694  * gtk_tree_view_get_columns:
8695  * @tree_view: A #GtkTreeView
8696  *
8697  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
8698  * The returned list must be freed with g_list_free ().
8699  *
8700  * Return value: A list of #GtkTreeViewColumn s
8701  **/
8702 GList *
8703 gtk_tree_view_get_columns (GtkTreeView *tree_view)
8704 {
8705   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
8706
8707   return g_list_copy (tree_view->priv->columns);
8708 }
8709
8710 /**
8711  * gtk_tree_view_move_column_after:
8712  * @tree_view: A #GtkTreeView
8713  * @column: The #GtkTreeViewColumn to be moved.
8714  * @base_column: The #GtkTreeViewColumn to be moved relative to, or %NULL.
8715  *
8716  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
8717  * @column is placed in the first position.
8718  **/
8719 void
8720 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
8721                                  GtkTreeViewColumn *column,
8722                                  GtkTreeViewColumn *base_column)
8723 {
8724   GList *column_list_el, *base_el = NULL;
8725
8726   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8727
8728   column_list_el = g_list_find (tree_view->priv->columns, column);
8729   g_return_if_fail (column_list_el != NULL);
8730
8731   if (base_column)
8732     {
8733       base_el = g_list_find (tree_view->priv->columns, base_column);
8734       g_return_if_fail (base_el != NULL);
8735     }
8736
8737   if (column_list_el->prev == base_el)
8738     return;
8739
8740   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
8741   if (base_el == NULL)
8742     {
8743       column_list_el->prev = NULL;
8744       column_list_el->next = tree_view->priv->columns;
8745       if (column_list_el->next)
8746         column_list_el->next->prev = column_list_el;
8747       tree_view->priv->columns = column_list_el;
8748     }
8749   else
8750     {
8751       column_list_el->prev = base_el;
8752       column_list_el->next = base_el->next;
8753       if (column_list_el->next)
8754         column_list_el->next->prev = column_list_el;
8755       base_el->next = column_list_el;
8756     }
8757
8758   if (GTK_WIDGET_REALIZED (tree_view))
8759     {
8760       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8761       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view));
8762     }
8763
8764   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
8765 }
8766
8767 /**
8768  * gtk_tree_view_set_expander_column:
8769  * @tree_view: A #GtkTreeView
8770  * @column: %NULL, or the column to draw the expander arrow at.
8771  *
8772  * Sets the column to draw the expander arrow at. It must be in @tree_view.  If
8773  * @column is %NULL, then the expander arrow is always at the first visible
8774  * column.
8775  **/
8776 void
8777 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
8778                                    GtkTreeViewColumn *column)
8779 {
8780   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8781   if (column != NULL)
8782     g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
8783
8784   if (tree_view->priv->expander_column != column)
8785     {
8786       GList *list;
8787
8788       if (column)
8789         {
8790           /* Confirm that column is in tree_view */
8791           for (list = tree_view->priv->columns; list; list = list->next)
8792             if (list->data == column)
8793               break;
8794           g_return_if_fail (list != NULL);
8795         }
8796
8797       tree_view->priv->expander_column = column;
8798       g_object_notify (G_OBJECT (tree_view), "expander_column");
8799     }
8800 }
8801
8802 /**
8803  * gtk_tree_view_get_expander_column:
8804  * @tree_view: A #GtkTreeView
8805  *
8806  * Returns the column that is the current expander column.  This
8807  * column has the expander arrow drawn next to it.
8808  *
8809  * Return value: The expander column.
8810  **/
8811 GtkTreeViewColumn *
8812 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
8813 {
8814   GList *list;
8815
8816   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
8817
8818   for (list = tree_view->priv->columns; list; list = list->next)
8819     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
8820       return (GtkTreeViewColumn *) list->data;
8821   return NULL;
8822 }
8823
8824
8825 /**
8826  * gtk_tree_view_set_column_drag_function:
8827  * @tree_view: A #GtkTreeView.
8828  * @func: A function to determine which columns are reorderable, or %NULL.
8829  * @user_data: User data to be passed to @func, or %NULL
8830  * @destroy: Destroy notifier for @user_data, or %NULL
8831  *
8832  * Sets a user function for determining where a column may be dropped when
8833  * dragged.  This function is called on every column pair in turn at the
8834  * beginning of a column drag to determine where a drop can take place.  The
8835  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
8836  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
8837  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
8838  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
8839  * @tree_view reverts to the default behavior of allowing all columns to be
8840  * dropped everywhere.
8841  **/
8842 void
8843 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
8844                                         GtkTreeViewColumnDropFunc  func,
8845                                         gpointer                   user_data,
8846                                         GtkDestroyNotify           destroy)
8847 {
8848   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8849
8850   if (tree_view->priv->column_drop_func_data_destroy)
8851     (* tree_view->priv->column_drop_func_data_destroy) (tree_view->priv->column_drop_func_data);
8852
8853   tree_view->priv->column_drop_func = func;
8854   tree_view->priv->column_drop_func_data = user_data;
8855   tree_view->priv->column_drop_func_data_destroy = destroy;
8856 }
8857
8858 /**
8859  * gtk_tree_view_scroll_to_point:
8860  * @tree_view: a #GtkTreeView
8861  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
8862  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
8863  *
8864  * Scrolls the tree view such that the top-left corner of the visible
8865  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
8866  * in tree window coordinates.  The @tree_view must be realized before
8867  * this function is called.  If it isn't, you probably want to be
8868  * using gtk_tree_view_scroll_to_cell().
8869  *
8870  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
8871  **/
8872 void
8873 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
8874                                gint         tree_x,
8875                                gint         tree_y)
8876 {
8877   GtkAdjustment *hadj;
8878   GtkAdjustment *vadj;
8879
8880   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8881   g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
8882
8883   hadj = tree_view->priv->hadjustment;
8884   vadj = tree_view->priv->vadjustment;
8885
8886   if (tree_x != -1)
8887     gtk_adjustment_set_value (hadj, CLAMP (tree_x, hadj->lower, hadj->upper - hadj->page_size));
8888   if (tree_y != -1)
8889     gtk_adjustment_set_value (vadj, CLAMP (tree_y, vadj->lower, vadj->upper - vadj->page_size));
8890 }
8891
8892 /**
8893  * gtk_tree_view_scroll_to_cell
8894  * @tree_view: A #GtkTreeView.
8895  * @path: The path of the row to move to, or %NULL.
8896  * @column: The #GtkTreeViewColumn to move horizontally to, or %NULL.
8897  * @use_align: whether to use alignment arguments, or %FALSE.
8898  * @row_align: The vertical alignment of the row specified by @path.
8899  * @col_align: The horizontal alignment of the column specified by @column.
8900  *
8901  * Moves the alignments of @tree_view to the position specified by @column and
8902  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
8903  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
8904  * or @path need to be non-%NULL.  @row_align determines where the row is
8905  * placed, and @col_align determines where @column is placed.  Both are expected
8906  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
8907  * right/bottom alignment, 0.5 means center.
8908  *
8909  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
8910  * tree does the minimum amount of work to scroll the cell onto the screen.
8911  * This means that the cell will be scrolled to the edge closest to its current
8912  * position.  If the cell is currently visible on the screen, nothing is done.
8913  *
8914  * This function only works if the model is set, and @path is a valid row on the
8915  * model.  If the model changes before the @tree_view is realized, the centered
8916  * path will be modified to reflect this change.
8917  **/
8918 void
8919 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
8920                               GtkTreePath       *path,
8921                               GtkTreeViewColumn *column,
8922                               gboolean           use_align,
8923                               gfloat             row_align,
8924                               gfloat             col_align)
8925 {
8926   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8927   g_return_if_fail (tree_view->priv->model != NULL);
8928   g_return_if_fail (tree_view->priv->tree != NULL);
8929   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
8930   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
8931   g_return_if_fail (path != NULL || column != NULL);
8932
8933 #if 0
8934   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
8935            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
8936 #endif
8937   row_align = CLAMP (row_align, 0.0, 1.0);
8938   col_align = CLAMP (col_align, 0.0, 1.0);
8939
8940
8941   /* Note: Despite the benefits that come from having one code path for the
8942    * scrolling code, we short-circuit validate_visible_area's immplementation as
8943    * it is much slower than just going to the point.
8944    */
8945   if (! GTK_WIDGET_REALIZED (tree_view) ||
8946       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
8947     {
8948       if (tree_view->priv->scroll_to_path)
8949         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
8950
8951       tree_view->priv->scroll_to_path = NULL;
8952       tree_view->priv->scroll_to_column = NULL;
8953
8954       if (path)
8955         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
8956       if (column)
8957         tree_view->priv->scroll_to_column = column;
8958       tree_view->priv->scroll_to_use_align = use_align;
8959       tree_view->priv->scroll_to_row_align = row_align;
8960       tree_view->priv->scroll_to_col_align = col_align;
8961
8962       install_presize_handler (tree_view);
8963     }
8964   else
8965     {
8966       GdkRectangle cell_rect;
8967       GdkRectangle vis_rect;
8968       gint dest_x, dest_y;
8969
8970       gtk_tree_view_get_cell_area (tree_view, path, column, &cell_rect);
8971       gtk_tree_view_widget_to_tree_coords (tree_view, cell_rect.x, cell_rect.y, &(cell_rect.x), &(cell_rect.y));
8972       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
8973
8974       dest_x = vis_rect.x;
8975       dest_y = vis_rect.y;
8976
8977       if (column)
8978         {
8979           if (use_align)
8980             {
8981               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
8982             }
8983           else
8984             {
8985               if (cell_rect.x < vis_rect.x)
8986                 dest_x = cell_rect.x;
8987               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
8988                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
8989             }
8990         }
8991
8992       if (path)
8993         {
8994           if (use_align)
8995             {
8996               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
8997               dest_y = MAX (dest_y, 0);
8998             }
8999           else
9000             {
9001               if (cell_rect.y < vis_rect.y)
9002                 dest_y = cell_rect.y;
9003               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
9004                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
9005             }
9006         }
9007
9008       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
9009     }
9010 }
9011
9012 /**
9013  * gtk_tree_view_row_activated:
9014  * @tree_view: A #GtkTreeView
9015  * @path: The #GtkTreePath to be activated.
9016  * @column: The #GtkTreeViewColumn to be activated.
9017  *
9018  * Activates the cell determined by @path and @column.
9019  **/
9020 void
9021 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
9022                              GtkTreePath       *path,
9023                              GtkTreeViewColumn *column)
9024 {
9025   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9026
9027   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
9028 }
9029
9030
9031 static void
9032 gtk_tree_view_expand_all_helper (GtkRBTree  *tree,
9033                                  GtkRBNode  *node,
9034                                  gpointer  data)
9035 {
9036   GtkTreeView *tree_view = data;
9037
9038   if (node->children)
9039     _gtk_rbtree_traverse (node->children,
9040                           node->children->root,
9041                           G_PRE_ORDER,
9042                           gtk_tree_view_expand_all_helper,
9043                           data);
9044   else if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT && node->children == NULL)
9045     {
9046       GtkTreePath *path;
9047       GtkTreeIter iter;
9048       GtkTreeIter child;
9049
9050       node->children = _gtk_rbtree_new ();
9051       node->children->parent_tree = tree;
9052       node->children->parent_node = node;
9053       path = _gtk_tree_view_find_path (tree_view, tree, node);
9054       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
9055       gtk_tree_model_iter_children (tree_view->priv->model, &child, &iter);
9056       gtk_tree_view_build_tree (tree_view,
9057                                 node->children,
9058                                 &child,
9059                                 gtk_tree_path_get_depth (path) + 1,
9060                                 TRUE);
9061       gtk_tree_path_free (path);
9062     }
9063 }
9064
9065 /**
9066  * gtk_tree_view_expand_all:
9067  * @tree_view: A #GtkTreeView.
9068  *
9069  * Recursively expands all nodes in the @tree_view.
9070  **/
9071 void
9072 gtk_tree_view_expand_all (GtkTreeView *tree_view)
9073 {
9074   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9075
9076   if (tree_view->priv->tree == NULL)
9077     return;
9078
9079   _gtk_rbtree_traverse (tree_view->priv->tree,
9080                         tree_view->priv->tree->root,
9081                         G_PRE_ORDER,
9082                         gtk_tree_view_expand_all_helper,
9083                         tree_view);
9084 }
9085
9086 /* Timeout to animate the expander during expands and collapses */
9087 static gboolean
9088 expand_collapse_timeout (gpointer data)
9089 {
9090   GtkTreeView *tree_view = data;
9091   GtkRBNode *node;
9092   GtkRBTree *tree;
9093   gboolean expanding;
9094   gboolean redraw;
9095
9096   GDK_THREADS_ENTER ();
9097
9098   redraw = FALSE;
9099   expanding = TRUE;
9100
9101   node = tree_view->priv->expanded_collapsed_node;
9102   tree = tree_view->priv->expanded_collapsed_tree;
9103
9104   if (node->children == NULL)
9105     expanding = FALSE;
9106
9107   if (expanding)
9108     {
9109       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
9110         {
9111           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
9112           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
9113
9114           redraw = TRUE;
9115
9116         }
9117       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
9118         {
9119           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
9120
9121           redraw = TRUE;
9122         }
9123     }
9124   else
9125     {
9126       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
9127         {
9128           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
9129           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
9130
9131           redraw = TRUE;
9132         }
9133       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
9134         {
9135           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
9136
9137           redraw = TRUE;
9138
9139         }
9140     }
9141
9142   if (redraw)
9143     {
9144       gtk_tree_view_queue_draw_arrow (tree_view, tree, node, NULL);
9145
9146       GDK_THREADS_LEAVE ();
9147
9148       return TRUE;
9149     }
9150
9151   GDK_THREADS_LEAVE ();
9152
9153   return FALSE;
9154 }
9155
9156 /**
9157  * gtk_tree_view_collapse_all:
9158  * @tree_view: A #GtkTreeView.
9159  *
9160  * Recursively collapses all visible, expanded nodes in @tree_view.
9161  **/
9162 void
9163 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
9164 {
9165   GtkRBTree *tree;
9166   GtkRBNode *node;
9167   GtkTreePath *path;
9168   gint *indices;
9169
9170   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9171
9172   if (tree_view->priv->tree == NULL)
9173     return;
9174
9175   path = gtk_tree_path_new ();
9176   gtk_tree_path_down (path);
9177   indices = gtk_tree_path_get_indices (path);
9178
9179   tree = tree_view->priv->tree;
9180   node = tree->root;
9181   while (node && node->left != tree->nil)
9182     node = node->left;
9183
9184   while (node)
9185     {
9186       if (node->children)
9187         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
9188       indices[0]++;
9189       node = _gtk_rbtree_next (tree, node);
9190     }
9191
9192   gtk_tree_path_free (path);
9193 }
9194
9195 /**
9196  * gtk_tree_view_expand_to_path:
9197  * @tree_view: A #GtkTreeView.
9198  * @path: path to a row.
9199  *
9200  * Expands the row at @path. This will also expand all parent rows of
9201  * @path as necessary.
9202  *
9203  * Since: 2.2
9204  **/
9205 void
9206 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
9207                               GtkTreePath *path)
9208 {
9209   gint i, depth;
9210   gint *indices;
9211   GtkTreePath *tmp;
9212
9213   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9214   g_return_if_fail (path != NULL);
9215
9216   depth = gtk_tree_path_get_depth (path);
9217   indices = gtk_tree_path_get_indices (path);
9218
9219   tmp = gtk_tree_path_new ();
9220   g_return_if_fail (tmp != NULL);
9221
9222   for (i = 0; i < depth; i++)
9223     {
9224       gtk_tree_path_append_index (tmp, indices[i]);
9225       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
9226     }
9227
9228   gtk_tree_path_free (tmp);
9229 }
9230
9231 /* FIXME the bool return values for expand_row and collapse_row are
9232  * not analagous; they should be TRUE if the row had children and
9233  * was not already in the requested state.
9234  */
9235
9236
9237 static gboolean
9238 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
9239                                GtkTreePath *path,
9240                                GtkRBTree   *tree,
9241                                GtkRBNode   *node,
9242                                gboolean     open_all,
9243                                gboolean     animate)
9244 {
9245   GtkTreeIter iter;
9246   GtkTreeIter temp;
9247   gboolean expand;
9248
9249   if (node->children && !open_all)
9250     return FALSE;
9251
9252   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
9253     return FALSE;
9254
9255   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
9256   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
9257     return FALSE;
9258
9259
9260    if (node->children && open_all)
9261     {
9262       gboolean retval = FALSE;
9263       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
9264
9265       gtk_tree_path_append_index (tmp_path, 0);
9266       tree = node->children;
9267       node = tree->root;
9268       while (node->left != tree->nil)
9269         node = node->left;
9270       /* try to expand the children */
9271       do
9272         {
9273          gboolean t;
9274          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
9275                                             TRUE, animate);
9276          if (t)
9277            retval = TRUE;
9278
9279          gtk_tree_path_next (tmp_path);
9280          node = _gtk_rbtree_next (tree, node);
9281        }
9282       while (node != NULL);
9283
9284       gtk_tree_path_free (tmp_path);
9285
9286       return retval;
9287     }
9288
9289   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
9290
9291   if (expand)
9292     return FALSE;
9293
9294   node->children = _gtk_rbtree_new ();
9295   node->children->parent_tree = tree;
9296   node->children->parent_node = node;
9297
9298   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
9299
9300   gtk_tree_view_build_tree (tree_view,
9301                             node->children,
9302                             &temp,
9303                             gtk_tree_path_get_depth (path) + 1,
9304                             open_all);
9305
9306   if (tree_view->priv->expand_collapse_timeout)
9307     {
9308       g_source_remove (tree_view->priv->expand_collapse_timeout);
9309       tree_view->priv->expand_collapse_timeout = 0;
9310     }
9311
9312   if (tree_view->priv->expanded_collapsed_node != NULL)
9313     {
9314       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_EXPANDED);
9315       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_COLLAPSED);
9316
9317       tree_view->priv->expanded_collapsed_node = NULL;
9318     }
9319
9320   if (animate)
9321     {
9322       tree_view->priv->expand_collapse_timeout = g_timeout_add (50, expand_collapse_timeout, tree_view);
9323       tree_view->priv->expanded_collapsed_node = node;
9324       tree_view->priv->expanded_collapsed_tree = tree;
9325
9326       GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
9327     }
9328
9329   install_presize_handler (tree_view);
9330
9331   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
9332   return TRUE;
9333 }
9334
9335
9336 /**
9337  * gtk_tree_view_expand_row:
9338  * @tree_view: a #GtkTreeView
9339  * @path: path to a row
9340  * @open_all: whether to recursively expand, or just expand immediate children
9341  *
9342  * Opens the row so its children are visible.
9343  *
9344  * Return value: %TRUE if the row existed and had children
9345  **/
9346 gboolean
9347 gtk_tree_view_expand_row (GtkTreeView *tree_view,
9348                           GtkTreePath *path,
9349                           gboolean     open_all)
9350 {
9351   GtkRBTree *tree;
9352   GtkRBNode *node;
9353
9354   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
9355   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
9356   g_return_val_if_fail (path != NULL, FALSE);
9357
9358   if (_gtk_tree_view_find_node (tree_view,
9359                                 path,
9360                                 &tree,
9361                                 &node))
9362     return FALSE;
9363
9364   if (tree != NULL)
9365     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
9366   else
9367     return FALSE;
9368 }
9369
9370 static gboolean
9371 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
9372                                  GtkTreePath *path,
9373                                  GtkRBTree   *tree,
9374                                  GtkRBNode   *node,
9375                                  gboolean     animate)
9376 {
9377   GtkTreeIter iter;
9378   GtkTreeIter children;
9379   gboolean collapse;
9380   gint x, y;
9381   GList *list;
9382   GdkDisplay *display;
9383
9384   if (node->children == NULL)
9385     return FALSE;
9386
9387   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
9388
9389   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
9390
9391   if (collapse)
9392     return FALSE;
9393
9394   /* if the prelighted node is a child of us, we want to unprelight it.  We have
9395    * a chance to prelight the correct node below */
9396
9397   if (tree_view->priv->prelight_tree)
9398     {
9399       GtkRBTree *parent_tree;
9400       GtkRBNode *parent_node;
9401
9402       parent_tree = tree_view->priv->prelight_tree->parent_tree;
9403       parent_node = tree_view->priv->prelight_tree->parent_node;
9404       while (parent_tree)
9405         {
9406           if (parent_tree == tree && parent_node == node)
9407             {
9408               ensure_unprelighted (tree_view);
9409               break;
9410             }
9411           parent_node = parent_tree->parent_node;
9412           parent_tree = parent_tree->parent_tree;
9413         }
9414     }
9415
9416   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
9417
9418   for (list = tree_view->priv->columns; list; list = list->next)
9419     {
9420       GtkTreeViewColumn *column = list->data;
9421
9422       if (column->visible == FALSE)
9423         continue;
9424       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9425         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
9426     }
9427
9428   if (tree_view->priv->destroy_count_func)
9429     {
9430       GtkTreePath *child_path;
9431       gint child_count = 0;
9432       child_path = gtk_tree_path_copy (path);
9433       gtk_tree_path_down (child_path);
9434       if (node->children)
9435         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
9436       (* tree_view->priv->destroy_count_func) (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
9437       gtk_tree_path_free (child_path);
9438     }
9439
9440   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
9441     {
9442       GtkTreePath *cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9443
9444       if (gtk_tree_path_is_ancestor (path, cursor_path))
9445         {
9446           gtk_tree_row_reference_free (tree_view->priv->cursor);
9447           tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
9448                                                                       tree_view->priv->model,
9449                                                                       path);
9450         }
9451       gtk_tree_path_free (cursor_path);
9452     }
9453
9454   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
9455     {
9456       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
9457       if (gtk_tree_path_is_ancestor (path, anchor_path))
9458         {
9459           gtk_tree_row_reference_free (tree_view->priv->anchor);
9460           tree_view->priv->anchor = NULL;
9461         }
9462       gtk_tree_path_free (anchor_path);
9463     }
9464
9465   if (gtk_tree_row_reference_valid (tree_view->priv->last_button_press))
9466     {
9467       GtkTreePath *lsc = gtk_tree_row_reference_get_path (tree_view->priv->last_button_press);
9468       if (gtk_tree_path_is_ancestor (path, lsc))
9469         {
9470           gtk_tree_row_reference_free (tree_view->priv->last_button_press);
9471           tree_view->priv->last_button_press = NULL;
9472         }
9473       gtk_tree_path_free (lsc);
9474     }
9475
9476   if (gtk_tree_row_reference_valid (tree_view->priv->last_button_press_2))
9477     {
9478       GtkTreePath *lsc = gtk_tree_row_reference_get_path (tree_view->priv->last_button_press_2);
9479       if (gtk_tree_path_is_ancestor (path, lsc))
9480         {
9481           gtk_tree_row_reference_free (tree_view->priv->last_button_press_2);
9482           tree_view->priv->last_button_press_2 = NULL;
9483         }
9484       gtk_tree_path_free (lsc);
9485     }
9486
9487   if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children))
9488     {
9489       _gtk_rbtree_remove (node->children);
9490       g_signal_emit_by_name (tree_view->priv->selection, "changed");
9491     }
9492   else
9493     _gtk_rbtree_remove (node->children);
9494
9495   if (tree_view->priv->expand_collapse_timeout)
9496     {
9497       g_source_remove (tree_view->priv->expand_collapse_timeout);
9498       tree_view->priv->expand_collapse_timeout = 0;
9499     }
9500
9501   if (tree_view->priv->expanded_collapsed_node != NULL)
9502     {
9503       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_EXPANDED);
9504       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_COLLAPSED);
9505
9506       tree_view->priv->expanded_collapsed_node = NULL;
9507     }
9508
9509   if (animate)
9510     {
9511       tree_view->priv->expand_collapse_timeout = g_timeout_add (50, expand_collapse_timeout, tree_view);
9512       tree_view->priv->expanded_collapsed_node = node;
9513       tree_view->priv->expanded_collapsed_tree = tree;
9514
9515       GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
9516     }
9517
9518   if (GTK_WIDGET_MAPPED (tree_view))
9519     {
9520       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9521     }
9522
9523   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
9524
9525   /* now that we've collapsed all rows, we want to try to set the prelight
9526    * again. To do this, we fake a motion event and send it to ourselves. */
9527
9528   display = gdk_drawable_get_display (tree_view->priv->bin_window);
9529   if (gdk_display_get_window_at_pointer (display, &x, &y) == tree_view->priv->bin_window)
9530     {
9531       GdkEventMotion event;
9532       event.window = tree_view->priv->bin_window;
9533       event.x = x;
9534       event.y = y;
9535
9536       /* despite the fact this isn't a real event, I'm almost positive it will
9537        * never trigger a drag event.  maybe_drag is the only function that uses
9538        * more than just event.x and event.y. */
9539       gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
9540     }
9541   return TRUE;
9542 }
9543
9544 /**
9545  * gtk_tree_view_collapse_row:
9546  * @tree_view: a #GtkTreeView
9547  * @path: path to a row in the @tree_view
9548  *
9549  * Collapses a row (hides its child rows, if they exist).
9550  *
9551  * Return value: %TRUE if the row was collapsed.
9552  **/
9553 gboolean
9554 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
9555                             GtkTreePath *path)
9556 {
9557   GtkRBTree *tree;
9558   GtkRBNode *node;
9559
9560   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
9561   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
9562   g_return_val_if_fail (path != NULL, FALSE);
9563
9564   if (_gtk_tree_view_find_node (tree_view,
9565                                 path,
9566                                 &tree,
9567                                 &node))
9568     return FALSE;
9569
9570   if (tree == NULL || node->children == NULL)
9571     return FALSE;
9572
9573   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
9574 }
9575
9576 static void
9577 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
9578                                         GtkRBTree              *tree,
9579                                         GtkTreePath            *path,
9580                                         GtkTreeViewMappingFunc  func,
9581                                         gpointer                user_data)
9582 {
9583   GtkRBNode *node;
9584
9585   if (tree == NULL || tree->root == NULL)
9586     return;
9587
9588   node = tree->root;
9589
9590   while (node && node->left != tree->nil)
9591     node = node->left;
9592
9593   while (node)
9594     {
9595       if (node->children)
9596         {
9597           (* func) (tree_view, path, user_data);
9598           gtk_tree_path_down (path);
9599           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
9600           gtk_tree_path_up (path);
9601         }
9602       gtk_tree_path_next (path);
9603       node = _gtk_rbtree_next (tree, node);
9604     }
9605 }
9606
9607 /**
9608  * gtk_tree_view_map_expanded_rows:
9609  * @tree_view: A #GtkTreeView
9610  * @func: A function to be called
9611  * @data: User data to be passed to the function.
9612  *
9613  * Calls @func on all expanded rows.
9614  **/
9615 void
9616 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
9617                                  GtkTreeViewMappingFunc  func,
9618                                  gpointer                user_data)
9619 {
9620   GtkTreePath *path;
9621
9622   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9623   g_return_if_fail (func != NULL);
9624
9625   path = gtk_tree_path_new_first ();
9626
9627   gtk_tree_view_map_expanded_rows_helper (tree_view,
9628                                           tree_view->priv->tree,
9629                                           path, func, user_data);
9630
9631   gtk_tree_path_free (path);
9632 }
9633
9634 /**
9635  * gtk_tree_view_row_expanded:
9636  * @tree_view: A #GtkTreeView.
9637  * @path: A #GtkTreePath to test expansion state.
9638  *
9639  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
9640  *
9641  * Return value: %TRUE if #path is expanded.
9642  **/
9643 gboolean
9644 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
9645                             GtkTreePath *path)
9646 {
9647   GtkRBTree *tree;
9648   GtkRBNode *node;
9649
9650   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
9651   g_return_val_if_fail (path != NULL, FALSE);
9652
9653   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
9654
9655   if (node == NULL)
9656     return FALSE;
9657
9658   return (node->children != NULL);
9659 }
9660
9661 static const GtkTargetEntry row_targets[] = {
9662   { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
9663 };
9664
9665
9666 /**
9667  * gtk_tree_view_get_reorderable:
9668  * @tree_view: a #GtkTreeView
9669  *
9670  * Retrieves whether the user can reorder the tree via drag-and-drop. See
9671  * gtk_tree_view_set_reorderable().
9672  *
9673  * Return value: %TRUE if the tree can be reordered.
9674  **/
9675 gboolean
9676 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
9677 {
9678   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
9679
9680   return tree_view->priv->reorderable;
9681 }
9682
9683 /**
9684  * gtk_tree_view_set_reorderable:
9685  * @tree_view: A #GtkTreeView.
9686  * @reorderable: %TRUE, if the tree can be reordered.
9687  *
9688  * This function is a convenience function to allow you to reorder models that
9689  * support the #GtkDragSourceIface and the #GtkDragDestIface.  Both
9690  * #GtkTreeStore and #GtkListStore support these.  If @reorderable is %TRUE, then
9691  * the user can reorder the model by dragging and dropping rows.  The
9692  * developer can listen to these changes by connecting to the model's
9693  * signals.
9694  *
9695  * This function does not give you any degree of control over the order -- any
9696  * reorderering is allowed.  If more control is needed, you should probably
9697  * handle drag and drop manually.
9698  **/
9699 void
9700 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
9701                                gboolean     reorderable)
9702 {
9703   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9704
9705   reorderable = reorderable != FALSE;
9706
9707   if (tree_view->priv->reorderable == reorderable)
9708     return;
9709
9710   if (reorderable)
9711     {
9712       gtk_tree_view_enable_model_drag_source (tree_view,
9713                                               GDK_BUTTON1_MASK,
9714                                               row_targets,
9715                                               G_N_ELEMENTS (row_targets),
9716                                               GDK_ACTION_MOVE);
9717       gtk_tree_view_enable_model_drag_dest (tree_view,
9718                                             row_targets,
9719                                             G_N_ELEMENTS (row_targets),
9720                                             GDK_ACTION_MOVE);
9721     }
9722   else
9723     {
9724       gtk_tree_view_unset_rows_drag_source (tree_view);
9725       gtk_tree_view_unset_rows_drag_dest (tree_view);
9726     }
9727
9728   tree_view->priv->reorderable = reorderable;
9729
9730   g_object_notify (G_OBJECT (tree_view), "reorderable");
9731 }
9732
9733 static void
9734 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
9735                                GtkTreePath     *path,
9736                                gboolean         clear_and_select,
9737                                gboolean         clamp_node)
9738 {
9739   GtkRBTree *tree = NULL;
9740   GtkRBNode *node = NULL;
9741   GdkModifierType state = 0;
9742
9743   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
9744     {
9745       GtkTreePath *cursor_path;
9746       cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9747       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
9748       gtk_tree_path_free (cursor_path);
9749     }
9750
9751   gtk_tree_row_reference_free (tree_view->priv->cursor);
9752   gtk_get_current_event_state (&state);
9753
9754   tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
9755                                                               tree_view->priv->model,
9756                                                               path);
9757   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
9758   if (tree != NULL)
9759     {
9760       if (clear_and_select && !((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK))
9761         _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
9762                                                   node, tree, path,
9763                                                   state, FALSE);
9764
9765       if (clamp_node)
9766         {
9767           gtk_tree_view_clamp_node_visible (tree_view, tree, node);
9768           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
9769         }
9770     }
9771
9772   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
9773 }
9774
9775 /**
9776  * gtk_tree_view_get_cursor:
9777  * @tree_view: A #GtkTreeView
9778  * @path: A pointer to be filled with the current cursor path, or %NULL
9779  * @focus_column: A pointer to be filled with the current focus column, or %NULL
9780  *
9781  * Fills in @path and @focus_column with the current path and focus column.  If
9782  * the cursor isn't currently set, then *@path will be %NULL.  If no column
9783  * currently has focus, then *@focus_column will be %NULL.
9784  **/
9785 void
9786 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
9787                           GtkTreePath       **path,
9788                           GtkTreeViewColumn **focus_column)
9789 {
9790   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9791
9792   if (path)
9793     {
9794       if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
9795         *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9796       else
9797         *path = NULL;
9798     }
9799
9800   if (focus_column)
9801     {
9802       *focus_column = tree_view->priv->focus_column;
9803     }
9804 }
9805
9806 /**
9807  * gtk_tree_view_set_cursor:
9808  * @tree_view: A #GtkTreeView
9809  * @path: A #GtkTreePath
9810  * @focus_column: A #GtkTreeViewColumn, or %NULL
9811  * @start_editing: %TRUE if the specified cell should start being edited.
9812  *
9813  * Sets the current keyboard focus to be at @path, and selects it.  This is
9814  * useful when you want to focus the user's attention on a particular row.  If
9815  * @focus_column is not %NULL, then focus is given to the column specified by
9816  * it. Additionally, if @focus_column is specified, and @start_editing is
9817  * %TRUE, then editing should be started in the specified cell.
9818  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
9819  * in order to give keyboard focus to the widget.  Please note that editing
9820  * can only happen when the widget is realized.
9821  **/
9822 void
9823 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
9824                           GtkTreePath       *path,
9825                           GtkTreeViewColumn *focus_column,
9826                           gboolean           start_editing)
9827 {
9828   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
9829                                     NULL, start_editing);
9830 }
9831
9832 /**
9833  * gtk_tree_view_set_cursor_on_cell:
9834  * @tree_view: A #GtkTreeView
9835  * @path: A #GtkTreePath
9836  * @focus_column: A #GtkTreeViewColumn, or %NULL
9837  * @focus_cell: A #GtkCellRenderer, or %NULL
9838  * @start_editing: %TRUE if the specified cell should start being edited.
9839  *
9840  * Sets the current keyboard focus to be at @path, and selects it.  This is
9841  * useful when you want to focus the user's attention on a particular row.  If
9842  * @focus_column is not %NULL, then focus is given to the column specified by
9843  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
9844  * contains 2 or more editable or activatable cells, then focus is given to
9845  * the cell specified by @focus_cell. Additionally, if @focus_column is
9846  * specified, and @start_editing is %TRUE, then editing should be started in
9847  * the specified cell.  This function is often followed by
9848  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
9849  * widget.  Please note that editing can only happen when the widget is
9850  * realized.
9851  *
9852  * Since: 2.2
9853  **/
9854 void
9855 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
9856                                   GtkTreePath       *path,
9857                                   GtkTreeViewColumn *focus_column,
9858                                   GtkCellRenderer   *focus_cell,
9859                                   gboolean           start_editing)
9860 {
9861   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9862   g_return_if_fail (path != NULL);
9863   if (focus_column)
9864     g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (focus_column));
9865   if (focus_cell)
9866     {
9867       g_return_if_fail (focus_column);
9868       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
9869     }
9870
9871   gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
9872
9873   if (focus_column && focus_column->visible)
9874     {
9875       GList *list;
9876       gboolean column_in_tree = FALSE;
9877
9878       for (list = tree_view->priv->columns; list; list = list->next)
9879         if (list->data == focus_column)
9880           {
9881             column_in_tree = TRUE;
9882             break;
9883           }
9884       g_return_if_fail (column_in_tree);
9885       tree_view->priv->focus_column = focus_column;
9886       if (focus_cell)
9887         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
9888       if (start_editing)
9889         gtk_tree_view_start_editing (tree_view, path);
9890     }
9891 }
9892
9893 /**
9894  * gtk_tree_view_get_bin_window:
9895  * @tree_view: A #GtkTreeView
9896  *
9897  * Returns the window that @tree_view renders to.  This is used primarily to
9898  * compare to <literal>event->window</literal> to confirm that the event on
9899  * @tree_view is on the right window.
9900  *
9901  * Return value: A #GdkWindow, or %NULL when @tree_view hasn't been realized yet
9902  **/
9903 GdkWindow *
9904 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
9905 {
9906   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
9907
9908   return tree_view->priv->bin_window;
9909 }
9910
9911 /**
9912  * gtk_tree_view_get_path_at_pos:
9913  * @tree_view: A #GtkTreeView.
9914  * @x: The x position to be identified.
9915  * @y: The y position to be identified.
9916  * @path: A pointer to a #GtkTreePath pointer to be filled in, or %NULL
9917  * @column: A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
9918  * @cell_x: A pointer where the X coordinate relative to the cell can be placed, or %NULL
9919  * @cell_y: A pointer where the Y coordinate relative to the cell can be placed, or %NULL
9920  *
9921  * Finds the path at the point (@x, @y), relative to widget coordinates.  That
9922  * is, @x and @y are relative to an events coordinates. @x and @y must come
9923  * from an event on the @tree_view only where event->window ==
9924  * gtk_tree_view_get_bin (). It is primarily for things like popup menus.
9925  * If @path is non-%NULL, then it will be filled with the #GtkTreePath at that
9926  * point.  This path should be freed with gtk_tree_path_free().  If @column
9927  * is non-%NULL, then it will be filled with the column at that point.
9928  * @cell_x and @cell_y return the coordinates relative to the cell background
9929  * (i.e. the @background_area passed to gtk_cell_renderer_render()).  This
9930  * function is only meaningful if @tree_view is realized.
9931  *
9932  * Return value: %TRUE if a row exists at that coordinate.
9933  **/
9934 gboolean
9935 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
9936                                gint                x,
9937                                gint                y,
9938                                GtkTreePath       **path,
9939                                GtkTreeViewColumn **column,
9940                                gint               *cell_x,
9941                                gint               *cell_y)
9942 {
9943   GtkRBTree *tree;
9944   GtkRBNode *node;
9945   gint y_offset;
9946
9947   g_return_val_if_fail (tree_view != NULL, FALSE);
9948   g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
9949
9950   if (path)
9951     *path = NULL;
9952   if (column)
9953     *column = NULL;
9954
9955   if (tree_view->priv->tree == NULL)
9956     return FALSE;
9957
9958   if (x > tree_view->priv->hadjustment->upper)
9959     return FALSE;
9960
9961   if (x < 0 || y < 0)
9962     return FALSE;
9963
9964   if (column || cell_x)
9965     {
9966       GtkTreeViewColumn *tmp_column;
9967       GtkTreeViewColumn *last_column = NULL;
9968       GList *list;
9969       gint remaining_x = x;
9970       gboolean found = FALSE;
9971
9972       for (list = tree_view->priv->columns; list; list = list->next)
9973         {
9974           tmp_column = list->data;
9975
9976           if (tmp_column->visible == FALSE)
9977             continue;
9978
9979           last_column = tmp_column;
9980           if (remaining_x <= tmp_column->width)
9981             {
9982               found = TRUE;
9983
9984               if (column)
9985                 *column = tmp_column;
9986
9987               if (cell_x)
9988                 *cell_x = remaining_x;
9989
9990               break;
9991             }
9992           remaining_x -= tmp_column->width;
9993         }
9994
9995       if (!found)
9996         {
9997           if (column)
9998             *column = last_column;
9999
10000           if (cell_x)
10001             *cell_x = last_column->width + remaining_x;
10002         }
10003     }
10004
10005   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
10006                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
10007                                       &tree, &node);
10008
10009   if (tree == NULL)
10010     return FALSE;
10011
10012   if (cell_y)
10013     *cell_y = y_offset;
10014
10015   if (path)
10016     *path = _gtk_tree_view_find_path (tree_view, tree, node);
10017
10018   return TRUE;
10019 }
10020
10021
10022 /**
10023  * gtk_tree_view_get_cell_area:
10024  * @tree_view: a #GtkTreeView
10025  * @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
10026  * @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
10027  * @rect: rectangle to fill with cell rect
10028  *
10029  * Fills the bounding rectangle in tree window coordinates for the cell at the
10030  * row specified by @path and the column specified by @column.  If @path is
10031  * %NULL, or points to a path not currently displayed, the @y and @height fields
10032  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
10033  * fields will be filled with 0.  The sum of all cell rects does not cover the
10034  * entire tree; there are extra pixels in between rows, for example. The
10035  * returned rectangle is equivalent to the @cell_area passed to
10036  * gtk_cell_renderer_render().  This function is only valid if #tree_view is
10037  * realized.
10038  **/
10039 void
10040 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
10041                              GtkTreePath        *path,
10042                              GtkTreeViewColumn  *column,
10043                              GdkRectangle       *rect)
10044 {
10045   GtkRBTree *tree = NULL;
10046   GtkRBNode *node = NULL;
10047   gint vertical_separator;
10048   gint horizontal_separator;
10049
10050   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10051   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
10052   g_return_if_fail (rect != NULL);
10053   g_return_if_fail (!column || column->tree_view == (GtkWidget *) tree_view);
10054   g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
10055
10056   gtk_widget_style_get (GTK_WIDGET (tree_view),
10057                         "vertical_separator", &vertical_separator,
10058                         "horizontal_separator", &horizontal_separator,
10059                         NULL);
10060
10061   rect->x = 0;
10062   rect->y = 0;
10063   rect->width = 0;
10064   rect->height = 0;
10065
10066   if (column)
10067     {
10068       rect->x = column->button->allocation.x + horizontal_separator/2;
10069       rect->width = column->button->allocation.width - horizontal_separator;
10070     }
10071
10072   if (path)
10073     {
10074       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
10075
10076       /* Get vertical coords */
10077       if ((!ret && tree == NULL) || ret)
10078         return;
10079
10080       rect->y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
10081       rect->height = MAX (CELL_HEIGHT (node, vertical_separator), tree_view->priv->expander_size - vertical_separator);
10082
10083       if (gtk_tree_view_is_expander_column (tree_view, column) &&
10084           TREE_VIEW_DRAW_EXPANDERS (tree_view))
10085         {
10086           gint depth = gtk_tree_path_get_depth (path) - 1;
10087
10088           rect->x += depth * tree_view->priv->expander_size;
10089           rect->width -= depth * tree_view->priv->expander_size;
10090           rect->width = MAX (rect->width, 0);
10091         }
10092     }
10093 }
10094
10095 /**
10096  * gtk_tree_view_get_background_area:
10097  * @tree_view: a #GtkTreeView
10098  * @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
10099  * @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
10100  * @rect: rectangle to fill with cell background rect
10101  *
10102  * Fills the bounding rectangle in tree window coordinates for the cell at the
10103  * row specified by @path and the column specified by @column.  If @path is
10104  * %NULL, or points to a node not found in the tree, the @y and @height fields of
10105  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
10106  * fields will be filled with 0.  The returned rectangle is equivalent to the
10107  * @background_area passed to gtk_cell_renderer_render().  These background
10108  * areas tile to cover the entire tree window (except for the area used for
10109  * header buttons). Contrast with the @cell_area, returned by
10110  * gtk_tree_view_get_cell_area(), which returns only the cell itself, excluding
10111  * surrounding borders and the tree expander area.
10112  *
10113  **/
10114 void
10115 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
10116                                    GtkTreePath        *path,
10117                                    GtkTreeViewColumn  *column,
10118                                    GdkRectangle       *rect)
10119 {
10120   GtkRBTree *tree = NULL;
10121   GtkRBNode *node = NULL;
10122
10123   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10124   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
10125   g_return_if_fail (rect != NULL);
10126
10127   rect->x = 0;
10128   rect->y = 0;
10129   rect->width = 0;
10130   rect->height = 0;
10131
10132   if (path)
10133     {
10134       /* Get vertical coords */
10135
10136       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
10137           tree == NULL)
10138         return;
10139
10140       rect->y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
10141
10142       rect->height = MAX (BACKGROUND_HEIGHT (node), tree_view->priv->expander_size);
10143     }
10144
10145   if (column)
10146     {
10147       gint x2 = 0;
10148
10149       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
10150       rect->width = x2 - rect->x;
10151     }
10152 }
10153
10154 /**
10155  * gtk_tree_view_get_visible_rect:
10156  * @tree_view: a #GtkTreeView
10157  * @visible_rect: rectangle to fill
10158  *
10159  * Fills @visible_rect with the currently-visible region of the
10160  * buffer, in tree coordinates. Convert to widget coordinates with
10161  * gtk_tree_view_tree_to_widget_coords(). Tree coordinates start at
10162  * 0,0 for row 0 of the tree, and cover the entire scrollable area of
10163  * the tree.
10164  **/
10165 void
10166 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
10167                                 GdkRectangle *visible_rect)
10168 {
10169   GtkWidget *widget;
10170
10171   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10172
10173   widget = GTK_WIDGET (tree_view);
10174
10175   if (visible_rect)
10176     {
10177       visible_rect->x = tree_view->priv->hadjustment->value;
10178       visible_rect->y = tree_view->priv->vadjustment->value;
10179       visible_rect->width = widget->allocation.width;
10180       visible_rect->height = widget->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
10181     }
10182 }
10183
10184 /**
10185  * gtk_tree_view_widget_to_tree_coords:
10186  * @tree_view: a #GtkTreeView
10187  * @wx: widget X coordinate
10188  * @wy: widget Y coordinate
10189  * @tx: return location for tree X coordinate
10190  * @ty: return location for tree Y coordinate
10191  *
10192  * Converts widget coordinates to coordinates for the
10193  * tree window (the full scrollable area of the tree).
10194  *
10195  **/
10196 void
10197 gtk_tree_view_widget_to_tree_coords (GtkTreeView *tree_view,
10198                                      gint         wx,
10199                                      gint         wy,
10200                                      gint        *tx,
10201                                      gint        *ty)
10202 {
10203   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10204
10205   if (tx)
10206     *tx = wx + tree_view->priv->hadjustment->value;
10207   if (ty)
10208     *ty = wy + tree_view->priv->dy;
10209 }
10210
10211 /**
10212  * gtk_tree_view_tree_to_widget_coords:
10213  * @tree_view: a #GtkTreeView
10214  * @tx: tree X coordinate
10215  * @ty: tree Y coordinate
10216  * @wx: return location for widget X coordinate
10217  * @wy: return location for widget Y coordinate
10218  *
10219  * Converts tree coordinates (coordinates in full scrollable area of the tree)
10220  * to widget coordinates.
10221  *
10222  **/
10223 void
10224 gtk_tree_view_tree_to_widget_coords (GtkTreeView *tree_view,
10225                                      gint         tx,
10226                                      gint         ty,
10227                                      gint        *wx,
10228                                      gint        *wy)
10229 {
10230   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10231
10232   if (wx)
10233     *wx = tx - tree_view->priv->hadjustment->value;
10234   if (wy)
10235     *wy = ty - tree_view->priv->dy;
10236 }
10237
10238 static void
10239 unset_reorderable (GtkTreeView *tree_view)
10240 {
10241   if (tree_view->priv->reorderable)
10242     {
10243       tree_view->priv->reorderable = FALSE;
10244       g_object_notify (G_OBJECT (tree_view), "reorderable");
10245     }
10246 }
10247
10248 void
10249 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
10250                                         GdkModifierType           start_button_mask,
10251                                         const GtkTargetEntry     *targets,
10252                                         gint                      n_targets,
10253                                         GdkDragAction             actions)
10254 {
10255   TreeViewDragInfo *di;
10256
10257   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10258
10259   di = ensure_info (tree_view);
10260   clear_source_info (di);
10261
10262   di->start_button_mask = start_button_mask;
10263   di->source_target_list = gtk_target_list_new (targets, n_targets);
10264   di->source_actions = actions;
10265
10266   di->source_set = TRUE;
10267
10268   unset_reorderable (tree_view);
10269 }
10270
10271 void
10272 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
10273                                       const GtkTargetEntry     *targets,
10274                                       gint                      n_targets,
10275                                       GdkDragAction             actions)
10276 {
10277   TreeViewDragInfo *di;
10278
10279   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10280
10281   gtk_drag_dest_set (GTK_WIDGET (tree_view),
10282                      0,
10283                      NULL,
10284                      0,
10285                      actions);
10286
10287   di = ensure_info (tree_view);
10288   clear_dest_info (di);
10289
10290   if (targets)
10291     di->dest_target_list = gtk_target_list_new (targets, n_targets);
10292
10293   di->dest_set = TRUE;
10294
10295   unset_reorderable (tree_view);
10296 }
10297
10298 void
10299 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
10300 {
10301   TreeViewDragInfo *di;
10302
10303   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10304
10305   di = get_info (tree_view);
10306
10307   if (di)
10308     {
10309       if (di->source_set)
10310         {
10311           clear_source_info (di);
10312           di->source_set = FALSE;
10313         }
10314
10315       if (!di->dest_set && !di->source_set)
10316         remove_info (tree_view);
10317     }
10318
10319   unset_reorderable (tree_view);
10320 }
10321
10322 void
10323 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
10324 {
10325   TreeViewDragInfo *di;
10326
10327   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10328
10329   di = get_info (tree_view);
10330
10331   if (di)
10332     {
10333       if (di->dest_set)
10334         {
10335           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
10336           clear_dest_info (di);
10337           di->dest_set = FALSE;
10338         }
10339
10340       if (!di->dest_set && !di->source_set)
10341         remove_info (tree_view);
10342     }
10343
10344   unset_reorderable (tree_view);
10345 }
10346
10347 void
10348 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
10349                                  GtkTreePath            *path,
10350                                  GtkTreeViewDropPosition pos)
10351 {
10352   GtkTreePath *current_dest;
10353   /* Note; this function is exported to allow a custom DND
10354    * implementation, so it can't touch TreeViewDragInfo
10355    */
10356
10357   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10358
10359   current_dest = NULL;
10360
10361   if (tree_view->priv->drag_dest_row)
10362     current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
10363
10364   if (tree_view->priv->drag_dest_row)
10365     gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
10366
10367   tree_view->priv->drag_dest_pos = pos;
10368
10369   if (path)
10370     {
10371       tree_view->priv->drag_dest_row =
10372         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
10373       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
10374     }
10375   else
10376     tree_view->priv->drag_dest_row = NULL;
10377
10378   if (current_dest)
10379     {
10380       GtkRBTree *tree, *new_tree;
10381       GtkRBNode *node, *new_node;
10382
10383       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
10384       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
10385
10386       if (tree && node)
10387         {
10388           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
10389           if (new_tree && new_node)
10390             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
10391
10392           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
10393           if (new_tree && new_node)
10394             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
10395         }
10396       gtk_tree_path_free (current_dest);
10397     }
10398 }
10399
10400 void
10401 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
10402                                  GtkTreePath             **path,
10403                                  GtkTreeViewDropPosition  *pos)
10404 {
10405   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10406
10407   if (path)
10408     {
10409       if (tree_view->priv->drag_dest_row)
10410         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
10411       else
10412         *path = NULL;
10413     }
10414
10415   if (pos)
10416     *pos = tree_view->priv->drag_dest_pos;
10417 }
10418
10419 gboolean
10420 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
10421                                    gint                     drag_x,
10422                                    gint                     drag_y,
10423                                    GtkTreePath            **path,
10424                                    GtkTreeViewDropPosition *pos)
10425 {
10426   gint cell_y;
10427   gdouble offset_into_row;
10428   gdouble third;
10429   GdkRectangle cell;
10430   GtkTreeViewColumn *column = NULL;
10431   GtkTreePath *tmp_path = NULL;
10432
10433   /* Note; this function is exported to allow a custom DND
10434    * implementation, so it can't touch TreeViewDragInfo
10435    */
10436
10437   g_return_val_if_fail (tree_view != NULL, FALSE);
10438   g_return_val_if_fail (drag_x >= 0, FALSE);
10439   g_return_val_if_fail (drag_y >= 0, FALSE);
10440   g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
10441
10442
10443   if (path)
10444     *path = NULL;
10445
10446   if (tree_view->priv->tree == NULL)
10447     return FALSE;
10448
10449   /* If in the top third of a row, we drop before that row; if
10450    * in the bottom third, drop after that row; if in the middle,
10451    * and the row has children, drop into the row.
10452    */
10453
10454   if (!gtk_tree_view_get_path_at_pos (tree_view,
10455                                       drag_x,
10456                                       drag_y - TREE_VIEW_HEADER_HEIGHT (tree_view),
10457                                       &tmp_path,
10458                                       &column,
10459                                       NULL,
10460                                       &cell_y))
10461     return FALSE;
10462
10463   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
10464                                      &cell);
10465
10466   offset_into_row = cell_y;
10467
10468   if (path)
10469     *path = tmp_path;
10470   else
10471     gtk_tree_path_free (tmp_path);
10472
10473   tmp_path = NULL;
10474
10475   third = cell.height / 3.0;
10476
10477   if (pos)
10478     {
10479       if (offset_into_row < third)
10480         {
10481           *pos = GTK_TREE_VIEW_DROP_BEFORE;
10482         }
10483       else if (offset_into_row < (cell.height / 2.0))
10484         {
10485           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
10486         }
10487       else if (offset_into_row < third * 2.0)
10488         {
10489           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
10490         }
10491       else
10492         {
10493           *pos = GTK_TREE_VIEW_DROP_AFTER;
10494         }
10495     }
10496
10497   return TRUE;
10498 }
10499
10500
10501
10502 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
10503 /**
10504  * gtk_tree_view_create_row_drag_icon:
10505  * @tree_view: a #GtkTreeView
10506  * @path: a #GtkTreePath in @tree_view
10507  *
10508  * Creates a #GdkPixmap representation of the row at @path.  This image is used
10509  * for a drag icon.
10510  *
10511  * Return value: a newly-allocated pixmap of the drag icon.
10512  **/
10513 GdkPixmap *
10514 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
10515                                     GtkTreePath  *path)
10516 {
10517   GtkTreeIter   iter;
10518   GtkRBTree    *tree;
10519   GtkRBNode    *node;
10520   gint cell_offset;
10521   GList *list;
10522   GdkRectangle background_area;
10523   GdkRectangle expose_area;
10524   GtkWidget *widget;
10525   gint depth;
10526   /* start drawing inside the black outline */
10527   gint x = 1, y = 1;
10528   GdkDrawable *drawable;
10529   gint bin_window_width;
10530
10531   widget = GTK_WIDGET (tree_view);
10532
10533   depth = gtk_tree_path_get_depth (path);
10534
10535   _gtk_tree_view_find_node (tree_view,
10536                             path,
10537                             &tree,
10538                             &node);
10539
10540   if (tree == NULL)
10541     return NULL;
10542
10543   if (!gtk_tree_model_get_iter (tree_view->priv->model,
10544                                 &iter,
10545                                 path))
10546     return NULL;
10547
10548   cell_offset = x;
10549
10550   background_area.y = y;
10551   background_area.height = MAX (BACKGROUND_HEIGHT (node), tree_view->priv->expander_size);
10552
10553   gdk_drawable_get_size (tree_view->priv->bin_window,
10554                          &bin_window_width, NULL);
10555
10556   drawable = gdk_pixmap_new (tree_view->priv->bin_window,
10557                              bin_window_width + 2,
10558                              background_area.height + 2,
10559                              -1);
10560
10561   expose_area.x = 0;
10562   expose_area.y = 0;
10563   expose_area.width = bin_window_width + 2;
10564   expose_area.height = background_area.height + 2;
10565
10566   gdk_draw_rectangle (drawable,
10567                       widget->style->base_gc [GTK_WIDGET_STATE (widget)],
10568                       TRUE,
10569                       0, 0,
10570                       bin_window_width + 2,
10571                       background_area.height + 2);
10572
10573   for (list = tree_view->priv->columns; list; list = list->next)
10574     {
10575       GtkTreeViewColumn *column = list->data;
10576       GdkRectangle cell_area;
10577       gint vertical_separator;
10578
10579       if (!column->visible)
10580         continue;
10581
10582       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
10583                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
10584                                                node->children?TRUE:FALSE);
10585
10586       background_area.x = cell_offset;
10587       background_area.width = column->width;
10588
10589       cell_area = background_area;
10590
10591       gtk_widget_style_get (widget, "vertical_separator", &vertical_separator, NULL);
10592       cell_area.y += vertical_separator / 2;
10593       cell_area.height -= vertical_separator;
10594
10595       if (gtk_tree_view_is_expander_column (tree_view, column) &&
10596           TREE_VIEW_DRAW_EXPANDERS(tree_view))
10597         {
10598           cell_area.x += depth * tree_view->priv->expander_size;
10599           cell_area.width -= depth * tree_view->priv->expander_size;
10600         }
10601
10602       if (gtk_tree_view_column_cell_is_visible (column))
10603         _gtk_tree_view_column_cell_render (column,
10604                                            drawable,
10605                                            &background_area,
10606                                            &cell_area,
10607                                            &expose_area,
10608                                            0);
10609       cell_offset += column->width;
10610     }
10611
10612   gdk_draw_rectangle (drawable,
10613                       widget->style->black_gc,
10614                       FALSE,
10615                       0, 0,
10616                       bin_window_width + 1,
10617                       background_area.height + 1);
10618
10619   return drawable;
10620 }
10621
10622
10623 /**
10624  * gtk_tree_view_set_destroy_count_func:
10625  * @tree_view: A #GtkTreeView
10626  * @func: Function to be called when a view row is destroyed, or %NULL
10627  * @data: User data to be passed to @func, or %NULL
10628  * @destroy: Destroy notifier for @data, or %NULL
10629  *
10630  * This function should almost never be used.  It is meant for private use by
10631  * ATK for determining the number of visible children that are removed when the
10632  * user collapses a row, or a row is deleted.
10633  **/
10634 void
10635 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
10636                                       GtkTreeDestroyCountFunc  func,
10637                                       gpointer                 data,
10638                                       GtkDestroyNotify         destroy)
10639 {
10640   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10641
10642   if (tree_view->priv->destroy_count_destroy)
10643     (* tree_view->priv->destroy_count_destroy) (tree_view->priv->destroy_count_data);
10644
10645   tree_view->priv->destroy_count_func = func;
10646   tree_view->priv->destroy_count_data = data;
10647   tree_view->priv->destroy_count_destroy = destroy;
10648 }
10649
10650
10651 /*
10652  * Interactive search
10653  */
10654
10655 /**
10656  * gtk_tree_view_set_enable_search:
10657  * @tree_view: A #GtkTreeView
10658  * @enable_search: %TRUE, if the user can search interactively
10659  *
10660  * If @enable_search is set, then the user can type in text to search through
10661  * the tree interactively.
10662  */
10663 void
10664 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
10665                                  gboolean     enable_search)
10666 {
10667   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10668
10669   enable_search = !!enable_search;
10670
10671   if (tree_view->priv->enable_search != enable_search)
10672     {
10673        tree_view->priv->enable_search = enable_search;
10674        g_object_notify (G_OBJECT (tree_view), "enable_search");
10675     }
10676 }
10677
10678 /**
10679  * gtk_tree_view_get_enable_search:
10680  * @tree_view: A #GtkTreeView
10681  *
10682  * Returns whether or not the tree allows interactive searching.
10683  *
10684  * Return value: whether or not to let the user search interactively
10685  */
10686 gboolean
10687 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
10688 {
10689   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
10690
10691   return tree_view->priv->enable_search;
10692 }
10693
10694
10695 /**
10696  * gtk_tree_view_get_search_column:
10697  * @tree_view: A #GtkTreeView
10698  *
10699  * Gets the column searched on by the interactive search code.
10700  *
10701  * Return value: the column the interactive search code searches in.
10702  */
10703 gint
10704 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
10705 {
10706   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
10707
10708   return (tree_view->priv->search_column);
10709 }
10710
10711 /**
10712  * gtk_tree_view_set_search_column:
10713  * @tree_view: A #GtkTreeView
10714  * @column: the column of the model to search in
10715  *
10716  * Sets @column as the column where the interactive search code should
10717  * search in.  Additionally, turns on interactive searching. Note that
10718  * @column refers to a column of the model.
10719  */
10720 void
10721 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
10722                                  gint         column)
10723 {
10724   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10725   g_return_if_fail (column >= 0);
10726
10727   if (tree_view->priv->search_column == column)
10728     return;
10729
10730   tree_view->priv->search_column = column;
10731   g_object_notify (G_OBJECT (tree_view), "search_column");
10732 }
10733
10734 /**
10735  * gtk_tree_view_get_search_equal_func:
10736  * @tree_view: A #GtkTreeView
10737  *
10738  * Returns the compare function currently in use.
10739  *
10740  * Return value: the currently used compare function for the search code.
10741  */
10742
10743 GtkTreeViewSearchEqualFunc
10744 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
10745 {
10746   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10747
10748   return tree_view->priv->search_equal_func;
10749 }
10750
10751 /**
10752  * gtk_tree_view_set_search_equal_func:
10753  * @tree_view: A #GtkTreeView
10754  * @search_equal_func: the compare function to use during the search
10755  * @search_user_data: user data to pass to @search_equal_func, or %NULL
10756  * @search_destroy: Destroy notifier for @search_user_data, or %NULL
10757  *
10758  * Sets the compare function for the interactive search capabilities.
10759  **/
10760 void
10761 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
10762                                      GtkTreeViewSearchEqualFunc  search_equal_func,
10763                                      gpointer                    search_user_data,
10764                                      GtkDestroyNotify            search_destroy)
10765 {
10766   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10767   g_return_if_fail (search_equal_func !=NULL);
10768
10769   if (tree_view->priv->search_destroy)
10770     (* tree_view->priv->search_destroy) (tree_view->priv->search_user_data);
10771
10772   tree_view->priv->search_equal_func = search_equal_func;
10773   tree_view->priv->search_user_data = search_user_data;
10774   tree_view->priv->search_destroy = search_destroy;
10775   if (tree_view->priv->search_equal_func == NULL)
10776     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
10777 }
10778
10779 static void
10780 gtk_tree_view_search_dialog_destroy (GtkWidget   *search_dialog,
10781                                      GtkTreeView *tree_view)
10782 {
10783   GtkEntry *entry = (GtkEntry *)(gtk_container_get_children (GTK_CONTAINER (search_dialog)))->data;
10784   gint *selected_iter;
10785
10786   if (tree_view->priv->disable_popdown)
10787     return;
10788
10789   if (entry)
10790     {
10791       /* send focus-in event */
10792       send_focus_change (GTK_WIDGET (entry), FALSE);
10793     }
10794
10795   /* remove data from tree_view */
10796   g_object_set_data (G_OBJECT (tree_view), GTK_TREE_VIEW_SEARCH_DIALOG_KEY,
10797                      NULL);
10798
10799   selected_iter = g_object_get_data (G_OBJECT (search_dialog),
10800                                      "gtk-tree-view-selected-iter");
10801   if (selected_iter)
10802     g_free (selected_iter);
10803   g_object_set_data (G_OBJECT (search_dialog), "gtk-tree-view-selected-iter",
10804                      NULL);
10805
10806   gtk_widget_destroy (search_dialog);
10807 }
10808
10809 static void
10810 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
10811                                     GtkWidget   *search_dialog)
10812 {
10813   gint x, y;
10814   gint tree_x, tree_y;
10815   gint tree_width, tree_height;
10816   GdkWindow *tree_window = GTK_WIDGET (tree_view)->window;
10817   GdkScreen *screen = gdk_drawable_get_screen (tree_window);
10818   GtkRequisition requisition;
10819
10820   gtk_widget_realize (search_dialog);
10821
10822   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
10823   gdk_drawable_get_size (tree_window,
10824                          &tree_width,
10825                          &tree_height);
10826   gtk_widget_size_request (search_dialog, &requisition);
10827
10828   if (tree_x + tree_width - requisition.width > gdk_screen_get_width (screen))
10829     x = gdk_screen_get_width (screen) - requisition.width;
10830   else if (tree_x + tree_width - requisition.width < 0)
10831     x = 0;
10832   else
10833     x = tree_x + tree_width - requisition.width;
10834
10835   if (tree_y + tree_height > gdk_screen_get_height (screen))
10836     y = gdk_screen_get_height (screen) - requisition.height;
10837   else if (tree_y + tree_height < 0) /* isn't really possible ... */
10838     y = 0;
10839   else
10840     y = tree_y + tree_height;
10841
10842   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
10843 }
10844
10845 static void
10846 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
10847                                       GtkMenu  *menu,
10848                                       gpointer  data)
10849 {
10850   GtkTreeView *tree_view = (GtkTreeView *)data;
10851
10852   tree_view->priv->disable_popdown = 1;
10853   g_signal_connect (menu, "hide",
10854                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
10855 }
10856
10857 static gboolean
10858 gtk_tree_view_real_search_enable_popdown (gpointer data)
10859 {
10860   GtkTreeView *tree_view = (GtkTreeView *)data;
10861
10862   GDK_THREADS_ENTER ();
10863
10864   tree_view->priv->disable_popdown = 0;
10865
10866   GDK_THREADS_LEAVE ();
10867
10868   return FALSE;
10869 }
10870
10871 static void
10872 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
10873                                      gpointer   data)
10874 {
10875   g_timeout_add (200, gtk_tree_view_real_search_enable_popdown, data);
10876 }
10877
10878 static gboolean
10879 gtk_tree_view_search_delete_event (GtkWidget *widget,
10880                                    GdkEventAny *event,
10881                                    GtkTreeView *tree_view)
10882 {
10883   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
10884
10885   gtk_tree_view_search_dialog_destroy (widget, tree_view);
10886
10887   return TRUE;
10888 }
10889
10890 static gboolean
10891 gtk_tree_view_search_button_press_event (GtkWidget *widget,
10892                                          GdkEventButton *event,
10893                                          GtkTreeView *tree_view)
10894 {
10895   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
10896
10897   gtk_tree_view_search_dialog_destroy (widget, tree_view);
10898
10899   return TRUE;
10900 }
10901
10902 static gboolean
10903 gtk_tree_view_search_key_press_event (GtkWidget *widget,
10904                                       GdkEventKey *event,
10905                                       GtkTreeView *tree_view)
10906 {
10907   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
10908   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
10909
10910   /* close window */
10911   if (event->keyval == GDK_Escape ||
10912       event->keyval == GDK_Return ||
10913       event->keyval == GDK_Tab)
10914     {
10915       gtk_tree_view_search_dialog_destroy (widget, tree_view);
10916       return TRUE;
10917     }
10918
10919   /* select previous matching iter */
10920   if (event->keyval == GDK_Up)
10921     {
10922       gtk_tree_view_search_move (widget, tree_view, TRUE);
10923       return TRUE;
10924     }
10925
10926   /* select next matching iter */
10927   if (event->keyval == GDK_Down)
10928     {
10929       gtk_tree_view_search_move (widget, tree_view, FALSE);
10930       return TRUE;
10931     }
10932
10933   return FALSE;
10934 }
10935
10936 static void
10937 gtk_tree_view_search_move (GtkWidget   *window,
10938                            GtkTreeView *tree_view,
10939                            gboolean     up)
10940 {
10941   gboolean ret;
10942   gint *selected_iter;
10943   gint len;
10944   gint count = 0;
10945   gchar *text;
10946   GtkTreeIter iter;
10947   GtkTreeModel *model;
10948   GtkTreeSelection *selection;
10949
10950   text = g_object_get_data (G_OBJECT (window), "gtk-tree-view-text");
10951   selected_iter = g_object_get_data (G_OBJECT (window), "gtk-tree-view-selected-iter");
10952
10953   g_return_if_fail (text != NULL);
10954
10955   if (!selected_iter || (up && *selected_iter == 1))
10956     return;
10957
10958   len = strlen (text);
10959
10960   if (len < 1)
10961     return;
10962
10963   model = gtk_tree_view_get_model (tree_view);
10964   selection = gtk_tree_view_get_selection (tree_view);
10965
10966   /* search */
10967   gtk_tree_selection_unselect_all (selection);
10968   gtk_tree_model_get_iter_first (model, &iter);
10969
10970   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
10971                                    &count, up?((*selected_iter) - 1):((*selected_iter + 1)));
10972
10973   if (ret)
10974     {
10975       /* found */
10976       *selected_iter += up?(-1):(1);
10977     }
10978   else
10979     {
10980       /* return to old iter */
10981       count = 0;
10982       gtk_tree_model_get_iter_first (model, &iter);
10983       gtk_tree_view_search_iter (model, selection,
10984                                  &iter, text,
10985                                  &count, *selected_iter);
10986     }
10987 }
10988
10989 static gboolean
10990 gtk_tree_view_search_equal_func (GtkTreeModel *model,
10991                                  gint          column,
10992                                  const gchar  *key,
10993                                  GtkTreeIter  *iter,
10994                                  gpointer      search_data)
10995 {
10996   gboolean retval = TRUE;
10997   gchar *normalized_string;
10998   gchar *normalized_key;
10999   gchar *case_normalized_string;
11000   gchar *case_normalized_key;
11001   GValue value = {0,};
11002   GValue transformed = {0,};
11003   gint key_len;
11004
11005   gtk_tree_model_get_value (model, iter, column, &value);
11006
11007   g_value_init (&transformed, G_TYPE_STRING);
11008
11009   if (!g_value_transform (&value, &transformed))
11010     {
11011       g_value_unset (&value);
11012       return FALSE;
11013     }
11014
11015   g_value_unset (&value);
11016
11017   normalized_string = g_utf8_normalize (g_value_get_string (&transformed), -1, G_NORMALIZE_ALL);
11018   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
11019   case_normalized_string = g_utf8_casefold (normalized_string, -1);
11020   case_normalized_key = g_utf8_casefold (normalized_key, -1);
11021
11022   key_len = strlen (case_normalized_key);
11023
11024   if (!strncmp (case_normalized_key, case_normalized_string, key_len))
11025     retval = FALSE;
11026
11027   g_value_unset (&transformed);
11028   g_free (normalized_key);
11029   g_free (normalized_string);
11030   g_free (case_normalized_key);
11031   g_free (case_normalized_string);
11032
11033   return retval;
11034 }
11035
11036 static gboolean
11037 gtk_tree_view_search_iter (GtkTreeModel     *model,
11038                            GtkTreeSelection *selection,
11039                            GtkTreeIter      *iter,
11040                            const gchar      *text,
11041                            gint             *count,
11042                            gint              n)
11043 {
11044   GtkRBTree *tree = NULL;
11045   GtkRBNode *node = NULL;
11046   GtkTreePath *path;
11047
11048   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
11049
11050   path = gtk_tree_model_get_path (model, iter);
11051   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
11052
11053   do
11054     {
11055       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
11056         {
11057           (*count)++;
11058           if (*count == n)
11059             {
11060               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
11061                                             TRUE, 0.5, 0.0);
11062               gtk_tree_selection_select_iter (selection, iter);
11063               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
11064
11065               if (path)
11066                 gtk_tree_path_free (path);
11067
11068               return TRUE;
11069             }
11070         }
11071
11072       if (node->children)
11073         {
11074           gboolean has_child;
11075           GtkTreeIter tmp;
11076
11077           tree = node->children;
11078           node = tree->root;
11079
11080           while (node->left != tree->nil)
11081             node = node->left;
11082
11083           tmp = *iter;
11084           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
11085           gtk_tree_path_down (path);
11086
11087           /* sanity check */
11088           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
11089         }
11090       else
11091         {
11092           gboolean done = FALSE;
11093
11094           do
11095             {
11096               node = _gtk_rbtree_next (tree, node);
11097
11098               if (node)
11099                 {
11100                   gboolean has_next;
11101
11102                   has_next = gtk_tree_model_iter_next (model, iter);
11103
11104                   done = TRUE;
11105                   gtk_tree_path_next (path);
11106
11107                   /* sanity check */
11108                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
11109                 }
11110               else
11111                 {
11112                   gboolean has_parent;
11113                   GtkTreeIter tmp_iter = *iter;
11114
11115                   node = tree->parent_node;
11116                   tree = tree->parent_tree;
11117
11118                   if (!tree)
11119                     {
11120                       if (path)
11121                         gtk_tree_path_free (path);
11122
11123                       /* we've run out of tree, done with this func */
11124                       return FALSE;
11125                     }
11126
11127                   has_parent = gtk_tree_model_iter_parent (model,
11128                                                            iter,
11129                                                            &tmp_iter);
11130                   gtk_tree_path_up (path);
11131
11132                   /* sanity check */
11133                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
11134                 }
11135             }
11136           while (!done);
11137         }
11138     }
11139   while (1);
11140
11141   return FALSE;
11142 }
11143
11144 static void
11145 gtk_tree_view_search_init (GtkWidget   *entry,
11146                            GtkTreeView *tree_view)
11147 {
11148   gint ret;
11149   gint *selected_iter;
11150   gint len;
11151   gint count = 0;
11152   const gchar *text;
11153   GtkWidget *window;
11154   GtkTreeIter iter;
11155   GtkTreeModel *model;
11156   GtkTreeSelection *selection;
11157
11158   g_return_if_fail (GTK_IS_ENTRY (entry));
11159   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11160
11161   window = gtk_widget_get_parent (entry);
11162   text = gtk_entry_get_text (GTK_ENTRY (entry));
11163   len = strlen (text);
11164   model = gtk_tree_view_get_model (tree_view);
11165   selection = gtk_tree_view_get_selection (tree_view);
11166
11167   /* search */
11168   gtk_tree_selection_unselect_all (selection);
11169   selected_iter = g_object_get_data (G_OBJECT (window), "gtk-tree-view-selected-iter");
11170   if (selected_iter)
11171     g_free (selected_iter);
11172   g_object_set_data (G_OBJECT (window), "gtk-tree-view-selected-iter", NULL);
11173
11174   if (len < 1)
11175     return;
11176
11177   gtk_tree_model_get_iter_first (model, &iter);
11178
11179   ret = gtk_tree_view_search_iter (model, selection,
11180                                    &iter, text,
11181                                    &count, 1);
11182
11183   if (ret)
11184     {
11185       selected_iter = g_malloc (sizeof (int));
11186       *selected_iter = 1;
11187       g_object_set_data (G_OBJECT (window), "gtk-tree-view-selected-iter",
11188                          selected_iter);
11189     }
11190 }
11191
11192 static void
11193 gtk_tree_view_remove_widget (GtkCellEditable *cell_editable,
11194                              GtkTreeView     *tree_view)
11195 {
11196   if (tree_view->priv->edited_column == NULL)
11197     return;
11198
11199   _gtk_tree_view_column_stop_editing (tree_view->priv->edited_column);
11200   tree_view->priv->edited_column = NULL;
11201
11202   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
11203
11204   gtk_container_remove (GTK_CONTAINER (tree_view),
11205                         GTK_WIDGET (cell_editable));
11206 }
11207
11208 static gboolean
11209 gtk_tree_view_start_editing (GtkTreeView *tree_view,
11210                              GtkTreePath *cursor_path)
11211 {
11212   GtkTreeIter iter;
11213   GdkRectangle background_area;
11214   GdkRectangle cell_area;
11215   GtkCellEditable *editable_widget = NULL;
11216   gchar *path_string;
11217   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
11218   gint retval = FALSE;
11219   GtkRBTree *cursor_tree;
11220   GtkRBNode *cursor_node;
11221
11222   g_assert (tree_view->priv->focus_column);
11223
11224   if (! GTK_WIDGET_REALIZED (tree_view))
11225     return FALSE;
11226
11227   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
11228       cursor_node == NULL)
11229     return FALSE;
11230
11231   path_string = gtk_tree_path_to_string (cursor_path);
11232   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
11233
11234   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
11235
11236   gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
11237                                            tree_view->priv->model,
11238                                            &iter,
11239                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
11240                                            cursor_node->children?TRUE:FALSE);
11241   gtk_tree_view_get_background_area (tree_view,
11242                                      cursor_path,
11243                                      tree_view->priv->focus_column,
11244                                      &background_area);
11245   gtk_tree_view_get_cell_area (tree_view,
11246                                cursor_path,
11247                                tree_view->priv->focus_column,
11248                                &cell_area);
11249
11250   if (_gtk_tree_view_column_cell_event (tree_view->priv->focus_column,
11251                                         &editable_widget,
11252                                         NULL,
11253                                         path_string,
11254                                         &background_area,
11255                                         &cell_area,
11256                                         flags))
11257     {
11258       retval = TRUE;
11259       if (editable_widget != NULL)
11260         {
11261           gint left, right;
11262           GdkRectangle area;
11263           GtkCellRenderer *cell;
11264
11265           area = cell_area;
11266           cell = _gtk_tree_view_column_get_edited_cell (tree_view->priv->focus_column);
11267           _gtk_tree_view_column_get_neighbor_sizes (tree_view->priv->focus_column, cell, &left, &right);
11268
11269           area.x += left;
11270           area.width -= right + left;
11271
11272           gtk_tree_view_real_start_editing (tree_view,
11273                                             tree_view->priv->focus_column,
11274                                             cursor_path,
11275                                             editable_widget,
11276                                             &area,
11277                                             NULL,
11278                                             flags);
11279         }
11280
11281     }
11282   g_free (path_string);
11283   return retval;
11284 }
11285
11286 static void
11287 gtk_tree_view_real_start_editing (GtkTreeView       *tree_view,
11288                                   GtkTreeViewColumn *column,
11289                                   GtkTreePath       *path,
11290                                   GtkCellEditable   *cell_editable,
11291                                   GdkRectangle      *cell_area,
11292                                   GdkEvent          *event,
11293                                   guint              flags)
11294 {
11295   gint pre_val = tree_view->priv->vadjustment->value;
11296
11297   tree_view->priv->edited_column = column;
11298   _gtk_tree_view_column_start_editing (column, GTK_CELL_EDITABLE (cell_editable));
11299
11300   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
11301
11302   cell_area->y += pre_val - tree_view->priv->vadjustment->value;
11303
11304   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
11305   gtk_tree_view_put (tree_view,
11306                      GTK_WIDGET (cell_editable),
11307                      cell_area->x, cell_area->y, cell_area->width, cell_area->height);
11308   gtk_cell_editable_start_editing (GTK_CELL_EDITABLE (cell_editable),
11309                                    (GdkEvent *)event);
11310   gtk_widget_grab_focus (GTK_WIDGET (cell_editable));
11311   g_signal_connect (cell_editable, "remove_widget",
11312                     G_CALLBACK (gtk_tree_view_remove_widget), tree_view);
11313 }
11314
11315 static void
11316 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
11317                             gboolean     cancel_editing)
11318 {
11319   GtkTreeViewColumn *column;
11320
11321   if (tree_view->priv->edited_column == NULL)
11322     return;
11323
11324   /*
11325    * This is very evil. We need to do this, because
11326    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
11327    * later on. If gtk_tree_view_row_changed notices
11328    * tree_view->priv->edited_column != NULL, it'll call
11329    * gtk_tree_view_stop_editing again. Bad things will happen then.
11330    *
11331    * Please read that again if you intend to modify anything here.
11332    */
11333
11334   column = tree_view->priv->edited_column;
11335   tree_view->priv->edited_column = NULL;
11336
11337   if (! cancel_editing)
11338     gtk_cell_editable_editing_done (column->editable_widget);
11339
11340   tree_view->priv->edited_column = column;
11341
11342   gtk_cell_editable_remove_widget (column->editable_widget);
11343 }