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