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

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