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

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