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