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   gint bin_window_height;
3462   GtkTreePath *cursor_path;
3463   GtkTreePath *drag_dest_path;
3464   GList *last_column;
3465   gint vertical_separator;
3466   gint horizontal_separator;
3467   gint focus_line_width;
3468   gboolean allow_rules;
3469   gboolean has_special_cell;
3470   gboolean rtl;
3471   gint n_visible_columns;
3472   gint pointer_x, pointer_y;
3473   gboolean got_pointer = FALSE;
3474
3475   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
3476
3477   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
3478
3479   tree_view = GTK_TREE_VIEW (widget);
3480
3481   gtk_widget_style_get (widget,
3482                         "horizontal-separator", &horizontal_separator,
3483                         "vertical-separator", &vertical_separator,
3484                         "allow-rules", &allow_rules,
3485                         "focus-line-width", &focus_line_width,
3486                         NULL);
3487
3488   if (tree_view->priv->tree == NULL)
3489     {
3490       draw_empty_focus (tree_view, &event->area);
3491       return TRUE;
3492     }
3493
3494   /* clip event->area to the visible area */
3495   if (event->area.height < 0)
3496     return TRUE;
3497
3498   validate_visible_area (tree_view);
3499
3500   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, event->area.y);
3501
3502   if (new_y < 0)
3503     new_y = 0;
3504   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
3505   gdk_drawable_get_size (tree_view->priv->bin_window,
3506                          &bin_window_width, &bin_window_height);
3507
3508   if (tree_view->priv->height < bin_window_height)
3509     {
3510       gtk_paint_flat_box (widget->style,
3511                           event->window,
3512                           widget->state,
3513                           GTK_SHADOW_NONE,
3514                           &event->area,
3515                           widget,
3516                           "cell_even",
3517                           0, tree_view->priv->height,
3518                           bin_window_width, bin_window_height);
3519     }
3520
3521   if (node == NULL)
3522     return TRUE;
3523
3524   /* find the path for the node */
3525   path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
3526                                    tree,
3527                                    node);
3528   gtk_tree_model_get_iter (tree_view->priv->model,
3529                            &iter,
3530                            path);
3531   depth = gtk_tree_path_get_depth (path);
3532   gtk_tree_path_free (path);
3533
3534   cursor_path = NULL;
3535   drag_dest_path = NULL;
3536
3537   if (tree_view->priv->cursor)
3538     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
3539
3540   if (cursor_path)
3541     _gtk_tree_view_find_node (tree_view, cursor_path,
3542                               &cursor_tree, &cursor);
3543
3544   if (tree_view->priv->drag_dest_row)
3545     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
3546
3547   if (drag_dest_path)
3548     _gtk_tree_view_find_node (tree_view, drag_dest_path,
3549                               &drag_highlight_tree, &drag_highlight);
3550
3551
3552   n_visible_columns = 0;
3553   for (list = tree_view->priv->columns; list; list = list->next)
3554     {
3555       if (! GTK_TREE_VIEW_COLUMN (list->data)->visible)
3556         continue;
3557       n_visible_columns ++;
3558     }
3559
3560   /* Find the last column */
3561   for (last_column = rtl ? g_list_first (tree_view->priv->columns) : g_list_last (tree_view->priv->columns);
3562        last_column &&
3563          !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible) &&
3564          GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (last_column->data)->button);
3565        last_column = rtl ? last_column->next : last_column->prev)
3566     ;
3567
3568   /* Actually process the expose event.  To do this, we want to
3569    * start at the first node of the event, and walk the tree in
3570    * order, drawing each successive node.
3571    */
3572
3573   do
3574     {
3575       gboolean parity;
3576       gboolean is_separator = FALSE;
3577
3578       if (tree_view->priv->row_separator_func)
3579         {
3580           is_separator = (* tree_view->priv->row_separator_func) (tree_view->priv->model,
3581                                                                   &iter,
3582                                                                   tree_view->priv->row_separator_data);
3583         }
3584
3585       max_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
3586
3587       x_offset = -event->area.x;
3588       cell_offset = 0;
3589       highlight_x = 0; /* should match x coord of first cell */
3590
3591       background_area.y = y_offset + event->area.y;
3592       background_area.height = max_height;
3593
3594       flags = 0;
3595
3596       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
3597         flags |= GTK_CELL_RENDERER_PRELIT;
3598
3599       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3600         flags |= GTK_CELL_RENDERER_SELECTED;
3601
3602       parity = _gtk_rbtree_node_find_parity (tree, node);
3603
3604       /* we *need* to set cell data on all cells before the call
3605        * to _has_special_cell, else _has_special_cell() does not
3606        * return a correct value.
3607        */
3608       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
3609            list;
3610            list = (rtl ? list->prev : list->next))
3611         {
3612           GtkTreeViewColumn *column = list->data;
3613           gtk_tree_view_column_cell_set_cell_data (column,
3614                                                    tree_view->priv->model,
3615                                                    &iter,
3616                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
3617                                                    node->children?TRUE:FALSE);
3618         }
3619
3620       has_special_cell = gtk_tree_view_has_special_cell (tree_view);
3621
3622       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
3623            list;
3624            list = (rtl ? list->prev : list->next))
3625         {
3626           GtkTreeViewColumn *column = list->data;
3627           const gchar *detail = NULL;
3628           GtkStateType state;
3629
3630           if (!column->visible)
3631             continue;
3632
3633           if (cell_offset > event->area.x + event->area.width ||
3634               cell_offset + column->width < event->area.x)
3635             {
3636               cell_offset += column->width;
3637               continue;
3638             }
3639
3640           if (column->show_sort_indicator)
3641             flags |= GTK_CELL_RENDERER_SORTED;
3642           else
3643             flags &= ~GTK_CELL_RENDERER_SORTED;
3644
3645           if (cursor == node)
3646             flags |= GTK_CELL_RENDERER_FOCUSED;
3647           else
3648             flags &= ~GTK_CELL_RENDERER_FOCUSED;
3649
3650           background_area.x = cell_offset;
3651           background_area.width = column->width;
3652
3653           cell_area = background_area;
3654           cell_area.y += vertical_separator / 2;
3655           cell_area.x += horizontal_separator / 2;
3656           cell_area.height -= vertical_separator;
3657           cell_area.width -= horizontal_separator;
3658
3659           if (gdk_region_rect_in (event->region, &background_area) == GDK_OVERLAP_RECTANGLE_OUT)
3660             {
3661               cell_offset += column->width;
3662               continue;
3663             }
3664
3665           gtk_tree_view_column_cell_set_cell_data (column,
3666                                                    tree_view->priv->model,
3667                                                    &iter,
3668                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
3669                                                    node->children?TRUE:FALSE);
3670
3671           /* Select the detail for drawing the cell.  relevant
3672            * factors are parity, sortedness, and whether to
3673            * display rules.
3674            */
3675           if (allow_rules && tree_view->priv->has_rules)
3676             {
3677               if ((flags & GTK_CELL_RENDERER_SORTED) &&
3678                   n_visible_columns >= 3)
3679                 {
3680                   if (parity)
3681                     detail = "cell_odd_ruled_sorted";
3682                   else
3683                     detail = "cell_even_ruled_sorted";
3684                 }
3685               else
3686                 {
3687                   if (parity)
3688                     detail = "cell_odd_ruled";
3689                   else
3690                     detail = "cell_even_ruled";
3691                 }
3692             }
3693           else
3694             {
3695               if ((flags & GTK_CELL_RENDERER_SORTED) &&
3696                   n_visible_columns >= 3)
3697                 {
3698                   if (parity)
3699                     detail = "cell_odd_sorted";
3700                   else
3701                     detail = "cell_even_sorted";
3702                 }
3703               else
3704                 {
3705                   if (parity)
3706                     detail = "cell_odd";
3707                   else
3708                     detail = "cell_even";
3709                 }
3710             }
3711
3712           g_assert (detail);
3713
3714           if (widget->state == GTK_STATE_INSENSITIVE)
3715             state = GTK_STATE_INSENSITIVE;
3716           else if (flags & GTK_CELL_RENDERER_SELECTED)
3717             state = GTK_STATE_SELECTED;
3718           else
3719             state = GTK_STATE_NORMAL;
3720
3721           /* Draw background */
3722           gtk_paint_flat_box (widget->style,
3723                               event->window,
3724                               state,
3725                               GTK_SHADOW_NONE,
3726                               &event->area,
3727                               widget,
3728                               detail,
3729                               background_area.x,
3730                               background_area.y,
3731                               background_area.width,
3732                               background_area.height);
3733
3734           if (gtk_tree_view_is_expander_column (tree_view, column) &&
3735               TREE_VIEW_DRAW_EXPANDERS(tree_view))
3736             {
3737               if (!rtl)
3738                 cell_area.x += depth * tree_view->priv->expander_size;
3739               cell_area.width -= depth * tree_view->priv->expander_size;
3740
3741               /* If we have an expander column, the highlight underline
3742                * starts with that column, so that it indicates which
3743                * level of the tree we're dropping at.
3744                */
3745               highlight_x = cell_area.x;
3746               if (is_separator)
3747                 gtk_paint_hline (widget->style,
3748                                  event->window,
3749                                  state,
3750                                  &cell_area,
3751                                  widget,
3752                                  NULL,
3753                                  cell_area.x,
3754                                  cell_area.x + cell_area.width,
3755                                  cell_area.y + cell_area.height / 2);
3756               else
3757                 _gtk_tree_view_column_cell_render (column,
3758                                                    event->window,
3759                                                    &background_area,
3760                                                    &cell_area,
3761                                                    &event->area,
3762                                                    flags);
3763               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
3764                 {
3765                   if (!got_pointer)
3766                     {
3767                       gdk_window_get_pointer (tree_view->priv->bin_window,
3768                                               &pointer_x, &pointer_y, NULL);
3769                       got_pointer = TRUE;
3770                     }
3771
3772                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
3773                                             tree,
3774                                             node,
3775                                             pointer_x, pointer_y);
3776                 }
3777             }
3778           else
3779             {
3780               if (is_separator)
3781                 gtk_paint_hline (widget->style,
3782                                  event->window,
3783                                  state,
3784                                  &cell_area,
3785                                  widget,
3786                                  NULL,
3787                                  cell_area.x,
3788                                  cell_area.x + cell_area.width,
3789                                  cell_area.y + cell_area.height / 2);
3790               else
3791                 _gtk_tree_view_column_cell_render (column,
3792                                                    event->window,
3793                                                    &background_area,
3794                                                    &cell_area,
3795                                                    &event->area,
3796                                                    flags);
3797             }
3798           if (node == cursor && has_special_cell &&
3799               ((column == tree_view->priv->focus_column &&
3800                 GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) &&
3801                 GTK_WIDGET_HAS_FOCUS (widget)) ||
3802                (column == tree_view->priv->edited_column)))
3803             {
3804               _gtk_tree_view_column_cell_draw_focus (column,
3805                                                      event->window,
3806                                                      &background_area,
3807                                                      &cell_area,
3808                                                      &event->area,
3809                                                      flags);
3810             }
3811           cell_offset += column->width;
3812         }
3813
3814       if (node == drag_highlight)
3815         {
3816           /* Draw indicator for the drop
3817            */
3818           gint highlight_y = -1;
3819           GtkRBTree *tree = NULL;
3820           GtkRBNode *node = NULL;
3821           gint width;
3822
3823           switch (tree_view->priv->drag_dest_pos)
3824             {
3825             case GTK_TREE_VIEW_DROP_BEFORE:
3826               highlight_y = background_area.y - 1;
3827               if (highlight_y < 0)
3828                       highlight_y = 0;
3829               break;
3830
3831             case GTK_TREE_VIEW_DROP_AFTER:
3832               highlight_y = background_area.y + background_area.height - 1;
3833               break;
3834
3835             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
3836             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
3837               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
3838
3839               if (tree == NULL)
3840                 break;
3841               gdk_drawable_get_size (tree_view->priv->bin_window,
3842                                      &width, NULL);
3843               gtk_paint_focus (widget->style,
3844                                tree_view->priv->bin_window,
3845                                GTK_WIDGET_STATE (widget),
3846                                NULL,
3847                                widget,
3848                                "treeview-drop-indicator",
3849                                0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node)
3850                                - focus_line_width / 2,
3851                                width, ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node))
3852                                - focus_line_width + 1);
3853               break;
3854             }
3855
3856           if (highlight_y >= 0)
3857             {
3858               gdk_draw_line (event->window,
3859                              widget->style->black_gc,
3860                              highlight_x,
3861                              highlight_y,
3862                              bin_window_width - highlight_x,
3863                              highlight_y);
3864             }
3865         }
3866
3867       /* draw the big row-spanning focus rectangle, if needed */
3868       if (!has_special_cell && node == cursor &&
3869           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) &&
3870           GTK_WIDGET_HAS_FOCUS (widget))
3871         {
3872           gint width;
3873           GtkStateType focus_rect_state;
3874
3875           focus_rect_state =
3876             flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
3877             (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
3878              (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE :
3879               GTK_STATE_NORMAL));
3880
3881           gdk_drawable_get_size (tree_view->priv->bin_window,
3882                                  &width, NULL);
3883           gtk_paint_focus (widget->style,
3884                            tree_view->priv->bin_window,
3885                            focus_rect_state,
3886                            NULL,
3887                            widget,
3888                            "treeview",
3889                            0,
3890                            BACKGROUND_FIRST_PIXEL (tree_view, tree, node),
3891                            width,
3892                            ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)));
3893         }
3894
3895       y_offset += max_height;
3896       if (node->children)
3897         {
3898           GtkTreeIter parent = iter;
3899           gboolean has_child;
3900
3901           tree = node->children;
3902           node = tree->root;
3903
3904           g_assert (node != tree->nil);
3905
3906           while (node->left != tree->nil)
3907             node = node->left;
3908           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
3909                                                     &iter,
3910                                                     &parent);
3911           depth++;
3912
3913           /* Sanity Check! */
3914           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
3915         }
3916       else
3917         {
3918           gboolean done = FALSE;
3919           do
3920             {
3921               node = _gtk_rbtree_next (tree, node);
3922               if (node != NULL)
3923                 {
3924                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
3925                   done = TRUE;
3926
3927                   /* Sanity Check! */
3928                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
3929                 }
3930               else
3931                 {
3932                   GtkTreeIter parent_iter = iter;
3933                   gboolean has_parent;
3934
3935                   node = tree->parent_node;
3936                   tree = tree->parent_tree;
3937                   if (tree == NULL)
3938                     /* we should go to done to free some memory */
3939                     goto done;
3940                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
3941                                                            &iter,
3942                                                            &parent_iter);
3943                   depth--;
3944
3945                   /* Sanity check */
3946                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
3947                 }
3948             }
3949           while (!done);
3950         }
3951     }
3952   while (y_offset < event->area.height);
3953
3954  done:
3955   if (cursor_path)
3956     gtk_tree_path_free (cursor_path);
3957
3958   if (drag_dest_path)
3959     gtk_tree_path_free (drag_dest_path);
3960
3961   return FALSE;
3962 }
3963
3964 static gboolean
3965 gtk_tree_view_expose (GtkWidget      *widget,
3966                       GdkEventExpose *event)
3967 {
3968   GtkTreeView *tree_view;
3969
3970   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
3971
3972   tree_view = GTK_TREE_VIEW (widget);
3973
3974   if (event->window == tree_view->priv->bin_window)
3975     {
3976       gboolean retval;
3977       GList *tmp_list;
3978
3979       retval = gtk_tree_view_bin_expose (widget, event);
3980
3981       /* We can't just chain up to Container::expose as it will try to send the
3982        * event to the headers, so we handle propagating it to our children
3983        * (eg. widgets being edited) ourselves.
3984        */
3985       tmp_list = tree_view->priv->children;
3986       while (tmp_list)
3987         {
3988           GtkTreeViewChild *child = tmp_list->data;
3989           tmp_list = tmp_list->next;
3990
3991           gtk_container_propagate_expose (GTK_CONTAINER (tree_view), child->widget, event);
3992         }
3993
3994       return retval;
3995     }
3996
3997   else if (event->window == tree_view->priv->header_window)
3998     {
3999       GList *list;
4000
4001       for (list = tree_view->priv->columns; list != NULL; list = list->next)
4002         {
4003           GtkTreeViewColumn *column = list->data;
4004
4005           if (column == tree_view->priv->drag_column)
4006             continue;
4007
4008           if (column->visible)
4009             gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
4010                                             column->button,
4011                                             event);
4012         }
4013     }
4014   else if (event->window == tree_view->priv->drag_window)
4015     {
4016       gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
4017                                       tree_view->priv->drag_column->button,
4018                                       event);
4019     }
4020   return TRUE;
4021 }
4022
4023 enum
4024 {
4025   DROP_HOME,
4026   DROP_RIGHT,
4027   DROP_LEFT,
4028   DROP_END
4029 };
4030
4031 /* returns 0x1 when no column has been found -- yes it's hackish */
4032 static GtkTreeViewColumn *
4033 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
4034                                GtkTreeViewColumn *column,
4035                                gint               drop_position)
4036 {
4037   GtkTreeViewColumn *left_column = NULL;
4038   GtkTreeViewColumn *cur_column = NULL;
4039   GList *tmp_list;
4040
4041   if (!column->reorderable)
4042     return (GtkTreeViewColumn *)0x1;
4043
4044   switch (drop_position)
4045     {
4046       case DROP_HOME:
4047         /* find first column where we can drop */
4048         tmp_list = tree_view->priv->columns;
4049         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
4050           return (GtkTreeViewColumn *)0x1;
4051
4052         while (tmp_list)
4053           {
4054             g_assert (tmp_list);
4055
4056             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
4057             tmp_list = tmp_list->next;
4058
4059             if (left_column && left_column->visible == FALSE)
4060               continue;
4061
4062             if (!tree_view->priv->column_drop_func)
4063               return left_column;
4064
4065             if (!(*tree_view->priv->column_drop_func) (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4066               {
4067                 left_column = cur_column;
4068                 continue;
4069               }
4070
4071             return left_column;
4072           }
4073
4074         if (!tree_view->priv->column_drop_func)
4075           return left_column;
4076
4077         if ((*tree_view->priv->column_drop_func) (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
4078           return left_column;
4079         else
4080           return (GtkTreeViewColumn *)0x1;
4081         break;
4082
4083       case DROP_RIGHT:
4084         /* find first column after column where we can drop */
4085         tmp_list = tree_view->priv->columns;
4086
4087         for (; tmp_list; tmp_list = tmp_list->next)
4088           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
4089             break;
4090
4091         if (!tmp_list || !tmp_list->next)
4092           return (GtkTreeViewColumn *)0x1;
4093
4094         tmp_list = tmp_list->next;
4095         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
4096         tmp_list = tmp_list->next;
4097
4098         while (tmp_list)
4099           {
4100             g_assert (tmp_list);
4101
4102             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
4103             tmp_list = tmp_list->next;
4104
4105             if (left_column && left_column->visible == FALSE)
4106               {
4107                 left_column = cur_column;
4108                 if (tmp_list)
4109                   tmp_list = tmp_list->next;
4110                 continue;
4111               }
4112
4113             if (!tree_view->priv->column_drop_func)
4114               return left_column;
4115
4116             if (!(*tree_view->priv->column_drop_func) (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4117               {
4118                 left_column = cur_column;
4119                 continue;
4120               }
4121
4122             return left_column;
4123           }
4124
4125         if (!tree_view->priv->column_drop_func)
4126           return left_column;
4127
4128         if ((*tree_view->priv->column_drop_func) (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
4129           return left_column;
4130         else
4131           return (GtkTreeViewColumn *)0x1;
4132         break;
4133
4134       case DROP_LEFT:
4135         /* find first column before column where we can drop */
4136         tmp_list = tree_view->priv->columns;
4137
4138         for (; tmp_list; tmp_list = tmp_list->next)
4139           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
4140             break;
4141
4142         if (!tmp_list || !tmp_list->prev)
4143           return (GtkTreeViewColumn *)0x1;
4144
4145         tmp_list = tmp_list->prev;
4146         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
4147         tmp_list = tmp_list->prev;
4148
4149         while (tmp_list)
4150           {
4151             g_assert (tmp_list);
4152
4153             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
4154
4155             if (left_column && !left_column->visible)
4156               {
4157                 /*if (!tmp_list->prev)
4158                   return (GtkTreeViewColumn *)0x1;
4159                   */
4160 /*
4161                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
4162                 tmp_list = tmp_list->prev->prev;
4163                 continue;*/
4164
4165                 cur_column = left_column;
4166                 if (tmp_list)
4167                   tmp_list = tmp_list->prev;
4168                 continue;
4169               }
4170
4171             if (!tree_view->priv->column_drop_func)
4172               return left_column;
4173
4174             if ((*tree_view->priv->column_drop_func) (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4175               return left_column;
4176
4177             cur_column = left_column;
4178             tmp_list = tmp_list->prev;
4179           }
4180
4181         if (!tree_view->priv->column_drop_func)
4182           return NULL;
4183
4184         if ((*tree_view->priv->column_drop_func) (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
4185           return NULL;
4186         else
4187           return (GtkTreeViewColumn *)0x1;
4188         break;
4189
4190       case DROP_END:
4191         /* same as DROP_HOME case, but doing it backwards */
4192         tmp_list = g_list_last (tree_view->priv->columns);
4193         cur_column = NULL;
4194
4195         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
4196           return (GtkTreeViewColumn *)0x1;
4197
4198         while (tmp_list)
4199           {
4200             g_assert (tmp_list);
4201
4202             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
4203
4204             if (left_column && !left_column->visible)
4205               {
4206                 cur_column = left_column;
4207                 tmp_list = tmp_list->prev;
4208               }
4209
4210             if (!tree_view->priv->column_drop_func)
4211               return left_column;
4212
4213             if ((*tree_view->priv->column_drop_func) (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4214               return left_column;
4215
4216             cur_column = left_column;
4217             tmp_list = tmp_list->prev;
4218           }
4219
4220         if (!tree_view->priv->column_drop_func)
4221           return NULL;
4222
4223         if ((*tree_view->priv->column_drop_func) (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
4224           return NULL;
4225         else
4226           return (GtkTreeViewColumn *)0x1;
4227         break;
4228     }
4229
4230   return (GtkTreeViewColumn *)0x1;
4231 }
4232
4233 static gboolean
4234 gtk_tree_view_key_press (GtkWidget   *widget,
4235                          GdkEventKey *event)
4236 {
4237   GtkTreeView *tree_view = (GtkTreeView *) widget;
4238   GList *list;
4239   gboolean rtl;
4240
4241   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
4242
4243   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
4244     {
4245       if (event->keyval == GDK_Escape)
4246         {
4247           tree_view->priv->cur_reorder = NULL;
4248           gtk_tree_view_button_release_drag_column (widget, NULL);
4249         }
4250       return TRUE;
4251     }
4252
4253   if (tree_view->priv->columns &&
4254       (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
4255       (event->keyval == GDK_Left || event->keyval == GDK_KP_Left
4256        || event->keyval == GDK_Right || event->keyval == GDK_KP_Right))
4257     {
4258       list = tree_view->priv->columns;
4259       while (list)
4260         {
4261           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (list->data);
4262           if (GTK_WIDGET_HAS_FOCUS (column->button))
4263             {
4264               if (!column->resizable)
4265                 return TRUE;
4266
4267               if (event->keyval == GDK_Left || event->keyval == GDK_KP_Left)
4268                 {
4269                   column->resized_width = MAX (column->resized_width,
4270                                                column->width);
4271                   column->resized_width -= 2;
4272                   if (column->resized_width < 0)
4273                     column->resized_width = 0;
4274
4275                   if (column->min_width == -1)
4276                     column->resized_width = MAX (column->button->requisition.width, column->resized_width);
4277                   else
4278                     column->resized_width = MAX (column->min_width, column->resized_width);
4279
4280                   if (column->max_width != -1)
4281                     column->resized_width = MIN (column->resized_width, column->max_width);
4282
4283                   column->use_resized_width = TRUE;
4284                   gtk_widget_queue_resize (widget);
4285                   return TRUE;
4286                 }
4287               else if (event->keyval == GDK_Right
4288                        || event->keyval == GDK_KP_Right)
4289                 {
4290                   column->resized_width = MAX (column->resized_width,
4291                                                column->width);
4292                   column->resized_width += 2;
4293
4294                   if (column->max_width != -1)
4295                     column->resized_width = MIN (column->resized_width, column->max_width);
4296
4297                   column->use_resized_width = TRUE;
4298                   gtk_widget_queue_resize (widget);
4299                   return TRUE;
4300                 }
4301             }
4302           list = list->next;
4303         }
4304     }
4305
4306   if (tree_view->priv->columns && (event->state & GDK_MOD1_MASK) &&
4307       (event->keyval == GDK_Left || event->keyval == GDK_KP_Left
4308        || event->keyval == GDK_Right || event->keyval == GDK_KP_Right
4309        || event->keyval == GDK_Home || event->keyval == GDK_KP_Home
4310        || event->keyval == GDK_End || event->keyval == GDK_KP_End))
4311     {
4312       list = tree_view->priv->columns;
4313       while (list)
4314         {
4315           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (list->data);
4316           if (GTK_WIDGET_HAS_FOCUS (column->button))
4317             {
4318               if (event->keyval == (rtl ? GDK_Right : GDK_Left)
4319                   || event->keyval == (rtl ? GDK_KP_Right : GDK_KP_Left))
4320                 {
4321                   GtkTreeViewColumn *col;
4322                   col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
4323                   if (col != (GtkTreeViewColumn *)0x1)
4324                     gtk_tree_view_move_column_after (tree_view, column, col);
4325                   return TRUE;
4326                 }
4327               else if (event->keyval == (rtl ? GDK_Left : GDK_Right)
4328                        || event->keyval == (rtl ? GDK_KP_Left : GDK_KP_Right))
4329                 {
4330                   GtkTreeViewColumn *col;
4331                   col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
4332                   if (col != (GtkTreeViewColumn *)0x1)
4333                     gtk_tree_view_move_column_after (tree_view, column, col);
4334                   return TRUE;
4335                 }
4336               else if (event->keyval == GDK_Home
4337                        || event->keyval == GDK_KP_Home)
4338                 {
4339                   GtkTreeViewColumn *col;
4340                   col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
4341                   if (col != (GtkTreeViewColumn *)0x1)
4342                     gtk_tree_view_move_column_after (tree_view, column, col);
4343                   return TRUE;
4344                 }
4345               else if (event->keyval == GDK_End || event->keyval == GDK_KP_End)
4346                 {
4347                   GtkTreeViewColumn *col;
4348                   col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
4349                   if (col != (GtkTreeViewColumn *)0x1)
4350                     gtk_tree_view_move_column_after (tree_view, column, col);
4351                   return TRUE;
4352                 }
4353             }
4354           list = list->next;
4355         }
4356     }
4357
4358   if (tree_view->priv->columns &&
4359       GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE) &&
4360       (event->keyval == GDK_Left || event->keyval == GDK_KP_Left
4361        || event->keyval == GDK_Right || event->keyval == GDK_KP_Right))
4362     {
4363       gint width = 0;
4364       list = tree_view->priv->columns;
4365       while (list)
4366         {
4367           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (list->data);
4368           if (GTK_WIDGET_HAS_FOCUS (column->button))
4369             {
4370               if ((event->keyval == (rtl ? GDK_Right : GDK_Left)
4371                    || event->keyval == (rtl ? GDK_KP_Right : GDK_KP_Left))
4372                   && list->prev)
4373                 {
4374                   GList *tmp;
4375
4376                   for (tmp = list->prev; tmp; tmp = tmp->prev)
4377                     if (GTK_TREE_VIEW_COLUMN (tmp->data)->visible)
4378                       break;
4379
4380                   if (!tmp)
4381                     return FALSE;
4382
4383                   tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp->data);
4384                   gtk_widget_grab_focus (tree_view->priv->focus_column->button);
4385                   width -= tree_view->priv->focus_column->width;
4386                   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));
4387                   return TRUE;
4388                 }
4389               else if ((event->keyval == (rtl ? GDK_Left : GDK_Right)
4390                         || event->keyval == (rtl ? GDK_KP_Left : GDK_KP_Right))
4391                        && list->next)
4392                 {
4393                   GList *tmp;
4394
4395                   for (tmp = list->next; tmp; tmp = tmp->next)
4396                     if (GTK_TREE_VIEW_COLUMN (tmp->data)->visible)
4397                       break;
4398
4399                   if (!tmp)
4400                     return FALSE;
4401
4402                   tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp->data);
4403
4404                   gtk_widget_grab_focus (tree_view->priv->focus_column->button);
4405                   width += tree_view->priv->focus_column->width;
4406                   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));
4407                   return TRUE;
4408                 }
4409             }
4410           width += GTK_TREE_VIEW_COLUMN (list->data)->width;
4411           list = list->next;
4412         }
4413     }
4414
4415   /* Chain up to the parent class.  It handles the keybindings. */
4416   if ((* GTK_WIDGET_CLASS (parent_class)->key_press_event) (widget, event))
4417     return TRUE;
4418
4419   /* We pass the event to the search_entry.  If its text changes, then we start
4420    * the typeahead find capabilities. */
4421   if (tree_view->priv->enable_search)
4422     {
4423       GdkEvent *new_event;
4424       char *old_text;
4425       const char *new_text;
4426       gboolean retval;
4427       GdkScreen *screen;
4428       gboolean text_modified;
4429       gulong popup_menu_id;
4430
4431       gtk_tree_view_ensure_interactive_directory (tree_view);
4432
4433       /* Make a copy of the current text */
4434       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
4435       new_event = gdk_event_copy ((GdkEvent *) event);
4436       ((GdkEventKey *) new_event)->window = tree_view->priv->search_entry->window;
4437       gtk_widget_realize (tree_view->priv->search_window);
4438
4439       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
4440                                         "popup_menu", G_CALLBACK (gtk_true), NULL);
4441
4442       /* Move the entry off screen */
4443       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
4444       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
4445                        gdk_screen_get_width (screen) + 1,
4446                        gdk_screen_get_height (screen) + 1);
4447       gtk_widget_show (tree_view->priv->search_window);
4448
4449       /* Send the event to the window.  If the preedit_changed signal is emitted
4450        * during this event, we will set priv->imcontext_changed  */
4451       tree_view->priv->imcontext_changed = FALSE;
4452       retval = gtk_widget_event (tree_view->priv->search_entry, new_event);
4453       gtk_widget_hide (tree_view->priv->search_window);
4454
4455       g_signal_handler_disconnect (tree_view->priv->search_entry,
4456                                    popup_menu_id);
4457
4458       /* We check to make sure that the entry tried to handle the text, and that
4459        * the text has changed.
4460        */
4461       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
4462       text_modified = strcmp (old_text, new_text) != 0;
4463       g_free (old_text);
4464       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
4465           (retval && text_modified))               /* ...or the text was modified */
4466         {
4467           if (gtk_tree_view_real_start_interactive_search (tree_view, FALSE))
4468             {
4469               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
4470               return TRUE;
4471             }
4472           else
4473             {
4474               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
4475               return FALSE;
4476             }
4477         }
4478     }
4479
4480   return FALSE;
4481 }
4482
4483 static gboolean
4484 gtk_tree_view_key_release (GtkWidget   *widget,
4485                            GdkEventKey *event)
4486 {
4487   return (* GTK_WIDGET_CLASS (parent_class)->key_release_event) (widget, event);
4488 }
4489
4490 /* FIXME Is this function necessary? Can I get an enter_notify event
4491  * w/o either an expose event or a mouse motion event?
4492  */
4493 static gboolean
4494 gtk_tree_view_enter_notify (GtkWidget        *widget,
4495                             GdkEventCrossing *event)
4496 {
4497   GtkTreeView *tree_view;
4498   GtkRBTree *tree;
4499   GtkRBNode *node;
4500   gint new_y;
4501
4502   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
4503
4504   tree_view = GTK_TREE_VIEW (widget);
4505
4506   /* Sanity check it */
4507   if (event->window != tree_view->priv->bin_window)
4508     return FALSE;
4509
4510   if (tree_view->priv->tree == NULL)
4511     return FALSE;
4512
4513   /* find the node internally */
4514   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4515   if (new_y < 0)
4516     new_y = 0;
4517   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4518
4519   if ((tree_view->priv->button_pressed_node == NULL) ||
4520       (tree_view->priv->button_pressed_node == node))
4521     prelight_or_select (tree_view, tree, node, event->x, event->y);
4522
4523   return TRUE;
4524 }
4525
4526 static gboolean
4527 gtk_tree_view_leave_notify (GtkWidget        *widget,
4528                             GdkEventCrossing *event)
4529 {
4530   GtkTreeView *tree_view;
4531
4532   tree_view = GTK_TREE_VIEW (widget);
4533   tree_view->priv->pressed_button = -1;
4534
4535   if (event->mode == GDK_CROSSING_GRAB)
4536     return TRUE;
4537
4538   if (tree_view->priv->prelight_node)
4539     _gtk_tree_view_queue_draw_node (tree_view,
4540                                    tree_view->priv->prelight_tree,
4541                                    tree_view->priv->prelight_node,
4542                                    NULL);
4543
4544   prelight_or_select (tree_view,
4545                       NULL, NULL,
4546                       -1000, -1000); /* coords not possibly over an arrow */
4547
4548   return TRUE;
4549 }
4550
4551
4552 static gint
4553 gtk_tree_view_focus_out (GtkWidget     *widget,
4554                          GdkEventFocus *event)
4555 {
4556   GtkTreeView *tree_view;
4557
4558   tree_view = GTK_TREE_VIEW (widget);
4559
4560   gtk_widget_queue_draw (widget);
4561
4562   /* destroy interactive search dialog */
4563   if (tree_view->priv->search_window)
4564     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view);
4565
4566   return FALSE;
4567 }
4568
4569
4570 /* Incremental Reflow
4571  */
4572
4573 static void
4574 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
4575                                  GtkRBTree   *tree,
4576                                  GtkRBNode   *node)
4577 {
4578   gint y;
4579
4580   y = _gtk_rbtree_node_find_offset (tree, node)
4581     - tree_view->priv->vadjustment->value
4582     + TREE_VIEW_HEADER_HEIGHT (tree_view);
4583
4584   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
4585                               0, y,
4586                               GTK_WIDGET (tree_view)->allocation.width,
4587                               GTK_RBNODE_GET_HEIGHT (node));
4588 }
4589
4590 /* Returns TRUE if it updated the size
4591  */
4592 static gboolean
4593 validate_row (GtkTreeView *tree_view,
4594               GtkRBTree   *tree,
4595               GtkRBNode   *node,
4596               GtkTreeIter *iter,
4597               GtkTreePath *path)
4598 {
4599   GtkTreeViewColumn *column;
4600   GList *list;
4601   gint height = 0;
4602   gint horizontal_separator;
4603   gint vertical_separator;
4604   gint focus_line_width;
4605   gint depth = gtk_tree_path_get_depth (path);
4606   gboolean retval = FALSE;
4607   gboolean is_separator = FALSE;
4608   gint focus_pad;
4609
4610   /* double check the row needs validating */
4611   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
4612       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
4613     return FALSE;
4614
4615   if (tree_view->priv->row_separator_func)
4616     {
4617       is_separator = (* tree_view->priv->row_separator_func) (tree_view->priv->model,
4618                                                               iter,
4619                                                               tree_view->priv->row_separator_data);
4620     }
4621
4622   gtk_widget_style_get (GTK_WIDGET (tree_view),
4623                         "focus-padding", &focus_pad,
4624                         "focus-line-width", &focus_line_width,
4625                         "horizontal-separator", &horizontal_separator,
4626                         "vertical-separator", &vertical_separator,
4627                         NULL);
4628
4629   for (list = tree_view->priv->columns; list; list = list->next)
4630     {
4631       gint tmp_width;
4632       gint tmp_height;
4633
4634       column = list->data;
4635
4636       if (! column->visible)
4637         continue;
4638
4639       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) && !column->dirty)
4640         continue;
4641
4642       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
4643                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4644                                                node->children?TRUE:FALSE);
4645       gtk_tree_view_column_cell_get_size (column,
4646                                           NULL, NULL, NULL,
4647                                           &tmp_width, &tmp_height);
4648
4649       if (!is_separator)
4650         {
4651           tmp_height += vertical_separator;
4652           height = MAX (height, tmp_height);
4653           height = MAX (height, tree_view->priv->expander_size);
4654         }
4655       else
4656         height = 2 + 2 * focus_pad;
4657
4658       if (gtk_tree_view_is_expander_column (tree_view, column) && TREE_VIEW_DRAW_EXPANDERS (tree_view))
4659         {
4660           tmp_width = tmp_width + horizontal_separator + depth * (tree_view->priv->expander_size);
4661         }
4662       else
4663         tmp_width = tmp_width + horizontal_separator;
4664
4665       if (tmp_width > column->requested_width)
4666         {
4667           retval = TRUE;
4668           column->requested_width = tmp_width;
4669         }
4670     }
4671
4672   if (height != GTK_RBNODE_GET_HEIGHT (node))
4673     {
4674       retval = TRUE;
4675       _gtk_rbtree_node_set_height (tree, node, height);
4676     }
4677   _gtk_rbtree_node_mark_valid (tree, node);
4678
4679   return retval;
4680 }
4681
4682
4683 static void
4684 validate_visible_area (GtkTreeView *tree_view)
4685 {
4686   GtkTreePath *path = NULL;
4687   GtkTreePath *above_path = NULL;
4688   GtkTreeIter iter;
4689   GtkRBTree *tree = NULL;
4690   GtkRBNode *node = NULL;
4691   gboolean need_redraw = FALSE;
4692   gboolean size_changed = FALSE;
4693   gboolean update_dy = FALSE;
4694   gint total_height;
4695   gint area_above = 0;
4696   gint area_below = 0;
4697
4698   if (tree_view->priv->tree == NULL)
4699     return;
4700
4701   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
4702       tree_view->priv->scroll_to_path == NULL)
4703     return;
4704
4705   total_height = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
4706
4707   if (total_height == 0)
4708     return;
4709
4710   /* First, we check to see if we need to scroll anywhere
4711    */
4712   if (tree_view->priv->scroll_to_path)
4713     {
4714       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
4715       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
4716         {
4717           /* we are going to scroll, and will update dy */
4718           update_dy = TRUE;
4719
4720           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
4721           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
4722               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
4723             {
4724               need_redraw = TRUE;
4725               if (validate_row (tree_view, tree, node, &iter, path))
4726                 size_changed = TRUE;
4727             }
4728
4729           if (tree_view->priv->scroll_to_use_align)
4730             {
4731               gint height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
4732               area_above = (total_height - height) *
4733                 tree_view->priv->scroll_to_row_align;
4734               area_below = total_height - area_above - height;
4735               area_above = MAX (area_above, 0);
4736               area_below = MAX (area_below, 0);
4737             }
4738           else
4739             {
4740               /* two cases:
4741                * 1) row not visible
4742                * 2) row visible
4743                */
4744               gint dy;
4745               gint height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
4746
4747               dy = _gtk_rbtree_node_find_offset (tree, node);
4748
4749               if (dy >= tree_view->priv->vadjustment->value &&
4750                   dy + height <= (tree_view->priv->vadjustment->value
4751                                   + tree_view->priv->vadjustment->page_size))
4752                 {
4753                   /* row visible: keep the row at the same position */
4754                   area_above = dy - tree_view->priv->vadjustment->value;
4755                   area_below = (tree_view->priv->vadjustment->value +
4756                                 tree_view->priv->vadjustment->page_size)
4757                                - dy - height;
4758                 }
4759               else
4760                 {
4761                   /* row not visible */
4762                   update_dy = TRUE;
4763
4764                   if (dy >= 0 && dy <= tree_view->priv->vadjustment->page_size)
4765                     {
4766                       /* row at the beginning -- fixed */
4767                       area_above = dy;
4768                       area_below = tree_view->priv->vadjustment->page_size
4769                                    - area_above - height;
4770                     }
4771                   else if (dy >= (tree_view->priv->vadjustment->upper -
4772                                   tree_view->priv->vadjustment->page_size)
4773                            && dy <= tree_view->priv->vadjustment->upper)
4774                     {
4775                       /* row at the end -- fixed */
4776                       area_above = dy - (tree_view->priv->vadjustment->upper -
4777                                    tree_view->priv->vadjustment->page_size);
4778                       area_below = tree_view->priv->vadjustment->page_size -
4779                                    area_above - height;
4780
4781                       if (area_below < 0)
4782                         {
4783                           area_above += area_below;
4784                           area_below = 0;
4785                         }
4786                     }
4787                   else
4788                     {
4789                       /* row somewhere in the middle, bring it to the top
4790                        * of the view
4791                        */
4792                       area_above = 0;
4793                       area_below = total_height - height;
4794                     }
4795                 }
4796             }
4797         }
4798       else
4799         /* the scroll to isn't valid; ignore it.
4800          */
4801         {
4802           if (tree_view->priv->scroll_to_path && !path)
4803             {
4804               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
4805               tree_view->priv->scroll_to_path = NULL;
4806             }
4807           if (path)
4808             gtk_tree_path_free (path);
4809           path = NULL;
4810         }
4811     }
4812
4813   /* We didn't have a scroll_to set, so we just handle things normally
4814    */
4815   if (path == NULL)
4816     {
4817       gint offset;
4818
4819       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
4820                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
4821                                         &tree, &node);
4822       if (node == NULL)
4823         {
4824           /* In this case, nothing has been validated */
4825           path = gtk_tree_path_new_first ();
4826           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
4827         }
4828       else
4829         {
4830           path = _gtk_tree_view_find_path (tree_view, tree, node);
4831           total_height += offset;
4832         }
4833
4834       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
4835
4836       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
4837           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
4838         {
4839           need_redraw = TRUE;
4840           if (validate_row (tree_view, tree, node, &iter, path))
4841             size_changed = TRUE;
4842         }
4843       area_above = 0;
4844       area_below = total_height - ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
4845     }
4846
4847   above_path = gtk_tree_path_copy (path);
4848
4849   /* if we do not validate any row above the new top_row, we will make sure
4850    * that the row immediately above top_row has been validated. (if we do not
4851    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
4852    * when invalidated that row's height will be zero. and this will mess up
4853    * scrolling).
4854    */
4855   if (area_above == 0)
4856     {
4857       GtkRBTree *tree;
4858       GtkRBNode *node;
4859       GtkTreePath *tmppath;
4860       GtkTreeIter iter;
4861
4862       _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
4863
4864       tmppath = gtk_tree_path_copy (above_path);
4865
4866       _gtk_rbtree_prev_full (tree, node, &tree, &node);
4867       if (! gtk_tree_path_prev (tmppath) && node != NULL)
4868         {
4869           gtk_tree_path_free (tmppath);
4870           tmppath = _gtk_tree_view_find_path (tree_view, tree, node);
4871         }
4872       gtk_tree_model_get_iter (tree_view->priv->model, &iter, tmppath);
4873
4874       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
4875           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
4876         {
4877           need_redraw = TRUE;
4878           if (validate_row (tree_view, tree, node, &iter, path))
4879             size_changed = TRUE;
4880         }
4881
4882       gtk_tree_path_free (tmppath);
4883     }
4884
4885   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
4886    * backwards is much slower then forward, as there is no iter_prev function.
4887    * We go forwards first in case we run out of tree.  Then we go backwards to
4888    * fill out the top.
4889    */
4890   while (node && area_below > 0)
4891     {
4892       gint new_height;
4893
4894       if (node->children)
4895         {
4896           GtkTreeIter parent = iter;
4897           gboolean has_child;
4898
4899           tree = node->children;
4900           node = tree->root;
4901
4902           g_assert (node != tree->nil);
4903
4904           while (node->left != tree->nil)
4905             node = node->left;
4906           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
4907                                                     &iter,
4908                                                     &parent);
4909           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
4910           gtk_tree_path_down (path);
4911         }
4912       else
4913         {
4914           gboolean done = FALSE;
4915           do
4916             {
4917               node = _gtk_rbtree_next (tree, node);
4918               if (node != NULL)
4919                 {
4920                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
4921                   done = TRUE;
4922                   gtk_tree_path_next (path);
4923
4924                   /* Sanity Check! */
4925                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
4926                 }
4927               else
4928                 {
4929                   GtkTreeIter parent_iter = iter;
4930                   gboolean has_parent;
4931
4932                   node = tree->parent_node;
4933                   tree = tree->parent_tree;
4934                   if (tree == NULL)
4935                     break;
4936                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
4937                                                            &iter,
4938                                                            &parent_iter);
4939                   gtk_tree_path_up (path);
4940
4941                   /* Sanity check */
4942                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
4943                 }
4944             }
4945           while (!done);
4946         }
4947
4948       if (!node)
4949         break;
4950
4951       new_height = GTK_RBNODE_GET_HEIGHT (node);
4952
4953       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
4954           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
4955         {
4956           gint old_height = new_height;
4957
4958           need_redraw = TRUE;
4959           if (validate_row (tree_view, tree, node, &iter, path))
4960             {
4961               new_height = GTK_RBNODE_GET_HEIGHT (node);
4962               size_changed = TRUE;
4963
4964               area_below -= new_height - old_height;
4965             }
4966         }
4967
4968       area_below -= ROW_HEIGHT (tree_view, new_height);
4969     }
4970   gtk_tree_path_free (path);
4971
4972   /* If we ran out of tree, and have extra area_below left, we need to add it
4973    * to area_above */
4974   if (area_below > 0)
4975     area_above += area_below;
4976
4977   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
4978
4979   /* We walk backwards */
4980   while (area_above > 0)
4981     {
4982       gint new_height;
4983
4984       _gtk_rbtree_prev_full (tree, node, &tree, &node);
4985       if (! gtk_tree_path_prev (above_path) && node != NULL)
4986         {
4987           gtk_tree_path_free (above_path);
4988           above_path = _gtk_tree_view_find_path (tree_view, tree, node);
4989         }
4990       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
4991
4992       if (node == NULL)
4993         break;
4994
4995       new_height = GTK_RBNODE_GET_HEIGHT (node);
4996
4997       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
4998           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
4999         {
5000           gint old_height = new_height;
5001
5002           need_redraw = TRUE;
5003           if (validate_row (tree_view, tree, node, &iter, above_path))
5004             {
5005               new_height = GTK_RBNODE_GET_HEIGHT (node);
5006               size_changed = TRUE;
5007
5008               area_above -= new_height - old_height;
5009             }
5010         }
5011       area_above -= ROW_HEIGHT (tree_view, new_height);
5012       update_dy = TRUE;
5013     }
5014
5015   /* if we scrolled to a path, we need to set the dy here,
5016    * and sync the top row accordingly
5017    */
5018   if (tree_view->priv->scroll_to_path)
5019     {
5020       gint dy;
5021
5022       if (node != NULL)
5023         dy = _gtk_rbtree_node_find_offset (tree, node) - area_above;
5024       else
5025         dy = 0;
5026
5027       gtk_adjustment_set_value (tree_view->priv->vadjustment, dy);
5028       gtk_tree_view_dy_to_top_row (tree_view);
5029
5030       need_redraw = TRUE;
5031     }
5032   else if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
5033     {
5034       /* when we are not scrolling, we should never set dy to something
5035        * else than zero. we update top_row to be in sync with dy = 0.
5036        */
5037       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
5038       gtk_tree_view_dy_to_top_row (tree_view);
5039     }
5040   else
5041     gtk_tree_view_top_row_to_dy (tree_view);
5042
5043   /* update width/height and queue a resize */
5044   if (size_changed)
5045     {
5046       GtkRequisition requisition;
5047
5048       /* We temporarily guess a size, under the assumption that it will be the
5049        * same when we get our next size_allocate.  If we don't do this, we'll be
5050        * in an inconsistent state if we call top_row_to_dy. */
5051
5052       gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
5053       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
5054       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
5055       gtk_adjustment_changed (tree_view->priv->hadjustment);
5056       gtk_adjustment_changed (tree_view->priv->vadjustment);
5057       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
5058     }
5059
5060   if (tree_view->priv->scroll_to_path)
5061     {
5062       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
5063       tree_view->priv->scroll_to_path = NULL;
5064     }
5065
5066   if (above_path)
5067     gtk_tree_path_free (above_path);
5068
5069   if (tree_view->priv->scroll_to_column)
5070     {
5071       tree_view->priv->scroll_to_column = NULL;
5072     }
5073   if (need_redraw)
5074     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
5075 }
5076
5077 static void
5078 initialize_fixed_height_mode (GtkTreeView *tree_view)
5079 {
5080   if (!tree_view->priv->tree)
5081     return;
5082
5083   if (tree_view->priv->fixed_height < 0)
5084     {
5085       GtkTreeIter iter;
5086       GtkTreePath *path;
5087
5088       GtkRBTree *tree = NULL;
5089       GtkRBNode *node = NULL;
5090
5091       tree = tree_view->priv->tree;
5092       node = tree->root;
5093
5094       path = _gtk_tree_view_find_path (tree_view, tree, node);
5095       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
5096
5097       validate_row (tree_view, tree, node, &iter, path);
5098
5099       gtk_tree_path_free (path);
5100
5101       tree_view->priv->fixed_height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5102     }
5103
5104    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
5105                                  tree_view->priv->fixed_height, TRUE);
5106 }
5107
5108 /* Our strategy for finding nodes to validate is a little convoluted.  We find
5109  * the left-most uninvalidated node.  We then try walking right, validating
5110  * nodes.  Once we find a valid node, we repeat the previous process of finding
5111  * the first invalid node.
5112  */
5113
5114 static gboolean
5115 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
5116 {
5117   GtkRBTree *tree = NULL;
5118   GtkRBNode *node = NULL;
5119   gboolean validated_area = FALSE;
5120   gint retval = TRUE;
5121   GtkTreePath *path = NULL;
5122   GtkTreeIter iter;
5123   gint i = 0;
5124
5125   gint prev_height = -1;
5126   gboolean fixed_height = TRUE;
5127
5128   g_assert (tree_view);
5129
5130   if (tree_view->priv->tree == NULL)
5131       return FALSE;
5132
5133   if (tree_view->priv->fixed_height_mode)
5134     {
5135       if (tree_view->priv->fixed_height < 0)
5136         initialize_fixed_height_mode (tree_view);
5137
5138       return FALSE;
5139     }
5140
5141   do
5142     {
5143       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
5144         {
5145           retval = FALSE;
5146           goto done;
5147         }
5148
5149       if (path != NULL)
5150         {
5151           node = _gtk_rbtree_next (tree, node);
5152           if (node != NULL)
5153             {
5154               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
5155               gtk_tree_path_next (path);
5156             }
5157           else
5158             {
5159               gtk_tree_path_free (path);
5160               path = NULL;
5161             }
5162         }
5163
5164       if (path == NULL)
5165         {
5166           tree = tree_view->priv->tree;
5167           node = tree_view->priv->tree->root;
5168
5169           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
5170
5171           do
5172             {
5173               if (node->left != tree->nil &&
5174                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
5175                 {
5176                   node = node->left;
5177                 }
5178               else if (node->right != tree->nil &&
5179                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
5180                 {
5181                   node = node->right;
5182                 }
5183               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
5184                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5185                 {
5186                   break;
5187                 }
5188               else if (node->children != NULL)
5189                 {
5190                   tree = node->children;
5191                   node = tree->root;
5192                 }
5193               else
5194                 /* RBTree corruption!  All bad */
5195                 g_assert_not_reached ();
5196             }
5197           while (TRUE);
5198           path = _gtk_tree_view_find_path (tree_view, tree, node);
5199           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
5200         }
5201
5202       validated_area = validate_row (tree_view, tree, node, &iter, path) ||
5203                        validated_area;
5204
5205       if (!tree_view->priv->fixed_height_check)
5206         {
5207           gint height;
5208
5209           height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5210           if (prev_height < 0)
5211             prev_height = height;
5212           else if (prev_height != height)
5213             fixed_height = FALSE;
5214         }
5215
5216       i++;
5217     }
5218   while (i < GTK_TREE_VIEW_NUM_ROWS_PER_IDLE);
5219
5220   if (!tree_view->priv->fixed_height_check)
5221    {
5222      if (fixed_height)
5223        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
5224
5225      tree_view->priv->fixed_height_check = 1;
5226    }
5227
5228  done:
5229   if (validated_area)
5230     {
5231       GtkRequisition requisition;
5232       /* We temporarily guess a size, under the assumption that it will be the
5233        * same when we get our next size_allocate.  If we don't do this, we'll be
5234        * in an inconsistent state when we call top_row_to_dy. */
5235
5236       gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
5237       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
5238       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
5239       gtk_adjustment_changed (tree_view->priv->hadjustment);
5240       gtk_adjustment_changed (tree_view->priv->vadjustment);
5241
5242       if (queue_resize)
5243         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
5244     }
5245
5246   if (path) gtk_tree_path_free (path);
5247
5248   return retval;
5249 }
5250
5251 static gboolean
5252 validate_rows (GtkTreeView *tree_view)
5253 {
5254   gboolean retval;
5255
5256   retval = do_validate_rows (tree_view, TRUE);
5257
5258   if (! retval && tree_view->priv->validate_rows_timer)
5259     {
5260       g_source_remove (tree_view->priv->validate_rows_timer);
5261       tree_view->priv->validate_rows_timer = 0;
5262     }
5263
5264   return retval;
5265 }
5266
5267 static gboolean
5268 validate_rows_handler (GtkTreeView *tree_view)
5269 {
5270   gboolean retval;
5271
5272   GDK_THREADS_ENTER ();
5273
5274   retval = do_validate_rows (tree_view, TRUE);
5275   if (! retval && tree_view->priv->validate_rows_timer)
5276     {
5277       g_source_remove (tree_view->priv->validate_rows_timer);
5278       tree_view->priv->validate_rows_timer = 0;
5279     }
5280
5281   GDK_THREADS_LEAVE ();
5282
5283   return retval;
5284 }
5285
5286 static gboolean
5287 do_presize_handler (GtkTreeView *tree_view)
5288 {
5289   if (tree_view->priv->mark_rows_col_dirty)
5290     {
5291       if (tree_view->priv->tree)
5292         _gtk_rbtree_column_invalid (tree_view->priv->tree);
5293       tree_view->priv->mark_rows_col_dirty = FALSE;
5294     }
5295   validate_visible_area (tree_view);
5296   tree_view->priv->presize_handler_timer = 0;
5297
5298   if (tree_view->priv->fixed_height_mode)
5299     {
5300       GtkRequisition requisition;
5301
5302       gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
5303
5304       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
5305       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
5306       gtk_adjustment_changed (tree_view->priv->hadjustment);
5307       gtk_adjustment_changed (tree_view->priv->vadjustment);
5308       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
5309     }
5310
5311   return FALSE;
5312 }
5313
5314 static gboolean
5315 presize_handler_callback (gpointer data)
5316 {
5317   GDK_THREADS_ENTER ();
5318
5319   do_presize_handler (GTK_TREE_VIEW (data));
5320
5321   GDK_THREADS_LEAVE ();
5322
5323   return FALSE;
5324 }
5325
5326 static void
5327 install_presize_handler (GtkTreeView *tree_view)
5328 {
5329   if (! GTK_WIDGET_REALIZED (tree_view))
5330     return;
5331
5332   if (! tree_view->priv->presize_handler_timer)
5333     {
5334       tree_view->priv->presize_handler_timer =
5335         g_idle_add_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
5336     }
5337   if (! tree_view->priv->validate_rows_timer)
5338     {
5339       tree_view->priv->validate_rows_timer =
5340         g_idle_add_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
5341     }
5342 }
5343
5344 static gboolean
5345 scroll_sync_handler (GtkTreeView *tree_view)
5346 {
5347
5348   GDK_THREADS_ENTER ();
5349
5350   if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
5351     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
5352   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
5353     gtk_tree_view_top_row_to_dy (tree_view);
5354   else
5355     gtk_tree_view_dy_to_top_row (tree_view);
5356
5357   tree_view->priv->scroll_sync_timer = 0;
5358
5359   GDK_THREADS_LEAVE ();
5360
5361   return FALSE;
5362 }
5363
5364 static void
5365 install_scroll_sync_handler (GtkTreeView *tree_view)
5366 {
5367   if (! GTK_WIDGET_REALIZED (tree_view))
5368     return;
5369
5370   if (!tree_view->priv->scroll_sync_timer)
5371     {
5372       tree_view->priv->scroll_sync_timer =
5373         g_idle_add_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
5374     }
5375 }
5376
5377 /* Always call this iff dy is in the visible range.  If the tree is empty, then
5378  * it's set to be NULL, and top_row_dy is 0;
5379  */
5380 static void
5381 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
5382 {
5383   GtkTreePath *path;
5384   GtkRBTree *tree;
5385   GtkRBNode *node;
5386
5387   gtk_tree_row_reference_free (tree_view->priv->top_row);
5388   if (tree_view->priv->tree == NULL)
5389     tree = NULL;
5390   else
5391     tree_view->priv->top_row_dy = _gtk_rbtree_find_offset (tree_view->priv->tree,
5392                                                            tree_view->priv->dy,
5393                                                            &tree, &node);
5394   if (tree == NULL)
5395     {
5396       tree_view->priv->top_row = NULL;
5397       tree_view->priv->top_row_dy = 0;
5398       return;
5399     }
5400
5401   path = _gtk_tree_view_find_path (tree_view, tree, node);
5402   tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
5403   gtk_tree_path_free (path);
5404 }
5405
5406 static void
5407 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
5408 {
5409   GtkTreePath *path;
5410   GtkRBTree *tree;
5411   GtkRBNode *node;
5412
5413   if (tree_view->priv->top_row)
5414     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
5415   else
5416     path = NULL;
5417
5418   if (!path)
5419     tree = NULL;
5420   else
5421     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
5422
5423   if (path)
5424     gtk_tree_path_free (path);
5425
5426   if (tree == NULL)
5427     {
5428       /* keep dy and set new toprow */
5429       gtk_tree_row_reference_free (tree_view->priv->top_row);
5430       tree_view->priv->top_row = NULL;
5431       tree_view->priv->top_row_dy = 0;
5432       /* DO NOT install the idle handler */
5433       gtk_tree_view_dy_to_top_row (tree_view);
5434       return;
5435     }
5436
5437   if (ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node))
5438       < tree_view->priv->top_row_dy)
5439     {
5440       /* new top row -- do NOT install the idle handler */
5441       gtk_tree_view_dy_to_top_row (tree_view);
5442       return;
5443     }
5444
5445   tree_view->priv->dy = _gtk_rbtree_node_find_offset (tree, node);
5446   tree_view->priv->dy += tree_view->priv->top_row_dy;
5447   gtk_adjustment_set_value (tree_view->priv->vadjustment,
5448                             (gdouble)tree_view->priv->dy);
5449 }
5450
5451
5452 void
5453 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view)
5454 {
5455   tree_view->priv->mark_rows_col_dirty = TRUE;
5456
5457   install_presize_handler (tree_view);
5458 }
5459
5460 /*
5461  * This function works synchronously (due to the while (validate_rows...)
5462  * loop).
5463  *
5464  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
5465  * here. You now need to check that yourself.
5466  */
5467 void
5468 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
5469                                 GtkTreeViewColumn *column)
5470 {
5471   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
5472   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
5473
5474   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
5475
5476   do_presize_handler (tree_view);
5477   while (validate_rows (tree_view));
5478
5479   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
5480 }
5481
5482 /* Drag-and-drop */
5483
5484 static void
5485 set_source_row (GdkDragContext *context,
5486                 GtkTreeModel   *model,
5487                 GtkTreePath    *source_row)
5488 {
5489   g_object_set_data_full (G_OBJECT (context),
5490                           "gtk-tree-view-source-row",
5491                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
5492                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
5493 }
5494
5495 static GtkTreePath*
5496 get_source_row (GdkDragContext *context)
5497 {
5498   GtkTreeRowReference *ref =
5499     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
5500
5501   if (ref)
5502     return gtk_tree_row_reference_get_path (ref);
5503   else
5504     return NULL;
5505 }
5506
5507 typedef struct
5508 {
5509   GtkTreeRowReference *dest_row;
5510   gboolean             path_down_mode;
5511   gboolean             empty_view_drop;
5512   gboolean             drop_append_mode;
5513 }
5514 DestRow;
5515
5516 static void
5517 dest_row_free (gpointer data)
5518 {
5519   DestRow *dr = (DestRow *)data;
5520
5521   gtk_tree_row_reference_free (dr->dest_row);
5522   g_free (dr);
5523 }
5524
5525
5526 static void
5527 set_dest_row (GdkDragContext *context,
5528               GtkTreeModel   *model,
5529               GtkTreePath    *dest_row,
5530               gboolean        path_down_mode,
5531               gboolean        empty_view_drop,
5532               gboolean        drop_append_mode)
5533 {
5534   DestRow *dr;
5535
5536   if (!dest_row)
5537     {
5538       g_object_set_data_full (G_OBJECT (context), "gtk-tree-view-dest-row",
5539                               NULL, NULL);
5540       return;
5541     }
5542
5543   dr = g_new0 (DestRow, 1);
5544
5545   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
5546   dr->path_down_mode = path_down_mode;
5547   dr->empty_view_drop = empty_view_drop;
5548   dr->drop_append_mode = drop_append_mode;
5549
5550   g_object_set_data_full (G_OBJECT (context), "gtk-tree-view-dest-row",
5551                           dr, (GDestroyNotify) dest_row_free);
5552 }
5553
5554 static GtkTreePath*
5555 get_dest_row (GdkDragContext *context,
5556               gboolean       *path_down_mode)
5557 {
5558   DestRow *dr =
5559     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
5560
5561   if (dr)
5562     {
5563       GtkTreePath *path = NULL;
5564
5565       if (path_down_mode)
5566         *path_down_mode = dr->path_down_mode;
5567
5568       if (dr->dest_row)
5569         path = gtk_tree_row_reference_get_path (dr->dest_row);
5570       else if (dr->empty_view_drop)
5571         path = gtk_tree_path_new_from_indices (0, -1);
5572       else
5573         path = NULL;
5574
5575       if (path && dr->drop_append_mode)
5576         gtk_tree_path_next (path);
5577
5578       return path;
5579     }
5580   else
5581     return NULL;
5582 }
5583
5584 /* Get/set whether drag_motion requested the drag data and
5585  * drag_data_received should thus not actually insert the data,
5586  * since the data doesn't result from a drop.
5587  */
5588 static void
5589 set_status_pending (GdkDragContext *context,
5590                     GdkDragAction   suggested_action)
5591 {
5592   g_object_set_data (G_OBJECT (context),
5593                      "gtk-tree-view-status-pending",
5594                      GINT_TO_POINTER (suggested_action));
5595 }
5596
5597 static GdkDragAction
5598 get_status_pending (GdkDragContext *context)
5599 {
5600   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
5601                                              "gtk-tree-view-status-pending"));
5602 }
5603
5604 static TreeViewDragInfo*
5605 get_info (GtkTreeView *tree_view)
5606 {
5607   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
5608 }
5609
5610 static void
5611 clear_source_info (TreeViewDragInfo *di)
5612 {
5613   if (di->source_target_list)
5614     gtk_target_list_unref (di->source_target_list);
5615
5616   di->source_target_list = NULL;
5617 }
5618
5619 static void
5620 clear_dest_info (TreeViewDragInfo *di)
5621 {
5622   if (di->dest_target_list)
5623     gtk_target_list_unref (di->dest_target_list);
5624
5625   di->dest_target_list = NULL;
5626 }
5627
5628 static void
5629 destroy_info (TreeViewDragInfo *di)
5630 {
5631   clear_source_info (di);
5632   clear_dest_info (di);
5633   g_free (di);
5634 }
5635
5636 static TreeViewDragInfo*
5637 ensure_info (GtkTreeView *tree_view)
5638 {
5639   TreeViewDragInfo *di;
5640
5641   di = get_info (tree_view);
5642
5643   if (di == NULL)
5644     {
5645       di = g_new0 (TreeViewDragInfo, 1);
5646
5647       g_object_set_data_full (G_OBJECT (tree_view),
5648                               "gtk-tree-view-drag-info",
5649                               di,
5650                               (GDestroyNotify) destroy_info);
5651     }
5652
5653   return di;
5654 }
5655
5656 static void
5657 remove_info (GtkTreeView *tree_view)
5658 {
5659   g_object_set_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info", NULL);
5660 }
5661
5662 #if 0
5663 static gint
5664 drag_scan_timeout (gpointer data)
5665 {
5666   GtkTreeView *tree_view;
5667   gint x, y;
5668   GdkModifierType state;
5669   GtkTreePath *path = NULL;
5670   GtkTreeViewColumn *column = NULL;
5671   GdkRectangle visible_rect;
5672
5673   GDK_THREADS_ENTER ();
5674
5675   tree_view = GTK_TREE_VIEW (data);
5676
5677   gdk_window_get_pointer (tree_view->priv->bin_window,
5678                           &x, &y, &state);
5679
5680   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
5681
5682   /* See if we are near the edge. */
5683   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
5684       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
5685       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
5686       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
5687     {
5688       gtk_tree_view_get_path_at_pos (tree_view,
5689                                      tree_view->priv->bin_window,
5690                                      x, y,
5691                                      &path,
5692                                      &column,
5693                                      NULL,
5694                                      NULL);
5695
5696       if (path != NULL)
5697         {
5698           gtk_tree_view_scroll_to_cell (tree_view,
5699                                         path,
5700                                         column,
5701                                         TRUE,
5702                                         0.5, 0.5);
5703
5704           gtk_tree_path_free (path);
5705         }
5706     }
5707
5708   GDK_THREADS_LEAVE ();
5709
5710   return TRUE;
5711 }
5712 #endif /* 0 */
5713
5714 static void
5715 remove_scroll_timeout (GtkTreeView *tree_view)
5716 {
5717   if (tree_view->priv->scroll_timeout != 0)
5718     {
5719       g_source_remove (tree_view->priv->scroll_timeout);
5720       tree_view->priv->scroll_timeout = 0;
5721     }
5722 }
5723 static gboolean
5724 check_model_dnd (GtkTreeModel *model,
5725                  GType         required_iface,
5726                  const gchar  *signal)
5727 {
5728   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
5729     {
5730       g_warning ("You must override the default '%s' handler "
5731                  "on GtkTreeView when using models that don't support "
5732                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
5733                  "is to connect to '%s' and call "
5734                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
5735                  "the default handler from running. Look at the source code "
5736                  "for the default handler in gtktreeview.c to get an idea what "
5737                  "your handler should do. (gtktreeview.c is in the GTK source "
5738                  "code.) If you're using GTK from a language other than C, "
5739                  "there may be a more natural way to override default handlers, e.g. via derivation.",
5740                  signal, g_type_name (required_iface), signal);
5741       return FALSE;
5742     }
5743   else
5744     return TRUE;
5745 }
5746
5747 static void
5748 remove_open_timeout (GtkTreeView *tree_view)
5749 {
5750   if (tree_view->priv->open_dest_timeout != 0)
5751     {
5752       g_source_remove (tree_view->priv->open_dest_timeout);
5753       tree_view->priv->open_dest_timeout = 0;
5754     }
5755 }
5756
5757
5758 static gint
5759 open_row_timeout (gpointer data)
5760 {
5761   GtkTreeView *tree_view = data;
5762   GtkTreePath *dest_path = NULL;
5763   GtkTreeViewDropPosition pos;
5764   gboolean result = FALSE;
5765
5766   GDK_THREADS_ENTER ();
5767
5768   gtk_tree_view_get_drag_dest_row (tree_view,
5769                                    &dest_path,
5770                                    &pos);
5771
5772   if (dest_path &&
5773       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
5774        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
5775     {
5776       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
5777       tree_view->priv->open_dest_timeout = 0;
5778
5779       gtk_tree_path_free (dest_path);
5780     }
5781   else
5782     {
5783       if (dest_path)
5784         gtk_tree_path_free (dest_path);
5785
5786       result = TRUE;
5787     }
5788
5789   GDK_THREADS_LEAVE ();
5790
5791   return result;
5792 }
5793
5794 static gint
5795 scroll_row_timeout (gpointer data)
5796 {
5797   GtkTreeView *tree_view = data;
5798
5799   GDK_THREADS_ENTER ();
5800
5801   gtk_tree_view_vertical_autoscroll (tree_view);
5802
5803   GDK_THREADS_LEAVE ();
5804
5805   return TRUE;
5806 }
5807
5808 /* Returns TRUE if event should not be propagated to parent widgets */
5809 static gboolean
5810 set_destination_row (GtkTreeView    *tree_view,
5811                      GdkDragContext *context,
5812                      gint            x,
5813                      gint            y,
5814                      GdkDragAction  *suggested_action,
5815                      GdkAtom        *target)
5816 {
5817   GtkTreePath *path = NULL;
5818   GtkTreeViewDropPosition pos;
5819   GtkTreeViewDropPosition old_pos;
5820   TreeViewDragInfo *di;
5821   GtkWidget *widget;
5822   GtkTreePath *old_dest_path = NULL;
5823   gboolean can_drop = FALSE;
5824
5825   *suggested_action = 0;
5826   *target = GDK_NONE;
5827
5828   widget = GTK_WIDGET (tree_view);
5829
5830   di = get_info (tree_view);
5831
5832   if (di == NULL || y - TREE_VIEW_HEADER_HEIGHT (tree_view) < 0)
5833     {
5834       /* someone unset us as a drag dest, note that if
5835        * we return FALSE drag_leave isn't called
5836        */
5837
5838       gtk_tree_view_set_drag_dest_row (tree_view,
5839                                        NULL,
5840                                        GTK_TREE_VIEW_DROP_BEFORE);
5841
5842       remove_scroll_timeout (GTK_TREE_VIEW (widget));
5843       remove_open_timeout (GTK_TREE_VIEW (widget));
5844
5845       return FALSE; /* no longer a drop site */
5846     }
5847
5848   *target = gtk_drag_dest_find_target (widget, context, di->dest_target_list);
5849   if (*target == GDK_NONE)
5850     {
5851       return FALSE;
5852     }
5853
5854   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
5855                                           x, y,
5856                                           &path,
5857                                           &pos))
5858     {
5859       gint n_children;
5860       GtkTreeModel *model;
5861
5862       remove_open_timeout (tree_view);
5863
5864       /* the row got dropped on empty space, let's setup a special case
5865        */
5866
5867       if (path)
5868         gtk_tree_path_free (path);
5869
5870       model = gtk_tree_view_get_model (tree_view);
5871
5872       n_children = gtk_tree_model_iter_n_children (model, NULL);
5873       if (n_children)
5874         {
5875           pos = GTK_TREE_VIEW_DROP_AFTER;
5876           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
5877         }
5878       else
5879         {
5880           pos = GTK_TREE_VIEW_DROP_BEFORE;
5881           path = gtk_tree_path_new_from_indices (0, -1);
5882         }
5883
5884       can_drop = TRUE;
5885
5886       goto out;
5887     }
5888
5889   g_assert (path);
5890
5891   /* If we left the current row's "open" zone, unset the timeout for
5892    * opening the row
5893    */
5894   gtk_tree_view_get_drag_dest_row (tree_view,
5895                                    &old_dest_path,
5896                                    &old_pos);
5897
5898   if (old_dest_path &&
5899       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
5900        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
5901          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
5902     remove_open_timeout (tree_view);
5903
5904   if (old_dest_path)
5905     gtk_tree_path_free (old_dest_path);
5906
5907   if (TRUE /* FIXME if the location droppable predicate */)
5908     {
5909       can_drop = TRUE;
5910     }
5911
5912 out:
5913   if (can_drop)
5914     {
5915       GtkWidget *source_widget;
5916
5917       *suggested_action = context->suggested_action;
5918       source_widget = gtk_drag_get_source_widget (context);
5919
5920       if (source_widget == widget)
5921         {
5922           /* Default to MOVE, unless the user has
5923            * pressed ctrl or shift to affect available actions
5924            */
5925           if ((context->actions & GDK_ACTION_MOVE) != 0)
5926             *suggested_action = GDK_ACTION_MOVE;
5927         }
5928
5929       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
5930                                        path, pos);
5931     }
5932   else
5933     {
5934       /* can't drop here */
5935       remove_open_timeout (tree_view);
5936
5937       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
5938                                        NULL,
5939                                        GTK_TREE_VIEW_DROP_BEFORE);
5940     }
5941
5942   if (path)
5943     gtk_tree_path_free (path);
5944
5945   return TRUE;
5946 }
5947
5948 static GtkTreePath*
5949 get_logical_dest_row (GtkTreeView *tree_view,
5950                       gboolean    *path_down_mode,
5951                       gboolean    *drop_append_mode)
5952 {
5953   /* adjust path to point to the row the drop goes in front of */
5954   GtkTreePath *path = NULL;
5955   GtkTreeViewDropPosition pos;
5956
5957   g_return_val_if_fail (path_down_mode != NULL, NULL);
5958   g_return_val_if_fail (drop_append_mode != NULL, NULL);
5959
5960   *path_down_mode = FALSE;
5961   *drop_append_mode = 0;
5962
5963   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
5964
5965   if (path == NULL)
5966     return NULL;
5967
5968   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
5969     ; /* do nothing */
5970   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
5971            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
5972     *path_down_mode = TRUE;
5973   else
5974     {
5975       GtkTreeIter iter;
5976       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
5977
5978       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
5979
5980       if (!gtk_tree_model_get_iter (model, &iter, path) ||
5981           !gtk_tree_model_iter_next (model, &iter))
5982         *drop_append_mode = 1;
5983       else
5984         {
5985           *drop_append_mode = 0;
5986           gtk_tree_path_next (path);
5987         }
5988     }
5989
5990   return path;
5991 }
5992
5993 static gboolean
5994 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
5995                                         GdkEventMotion   *event)
5996 {
5997   GdkDragContext *context;
5998   TreeViewDragInfo *di;
5999   GtkTreePath *path = NULL;
6000   gint button;
6001   gint cell_x, cell_y;
6002   GtkTreeModel *model;
6003   gboolean retval = FALSE;
6004
6005   di = get_info (tree_view);
6006
6007   if (di == NULL || !di->source_set)
6008     goto out;
6009
6010   if (tree_view->priv->pressed_button < 0)
6011     goto out;
6012
6013   if (!gtk_drag_check_threshold (GTK_WIDGET (tree_view),
6014                                  tree_view->priv->press_start_x,
6015                                  tree_view->priv->press_start_y,
6016                                  event->x, event->y))
6017     goto out;
6018
6019   model = gtk_tree_view_get_model (tree_view);
6020
6021   if (model == NULL)
6022     goto out;
6023
6024   button = tree_view->priv->pressed_button;
6025   tree_view->priv->pressed_button = -1;
6026
6027   gtk_tree_view_get_path_at_pos (tree_view,
6028                                  tree_view->priv->press_start_x,
6029                                  tree_view->priv->press_start_y,
6030                                  &path,
6031                                  NULL,
6032                                  &cell_x,
6033                                  &cell_y);
6034
6035   if (path == NULL)
6036     goto out;
6037
6038   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
6039       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
6040                                            path))
6041     goto out;
6042
6043   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
6044     goto out;
6045
6046   /* Now we can begin the drag */
6047
6048   retval = TRUE;
6049
6050   context = gtk_drag_begin (GTK_WIDGET (tree_view),
6051                             di->source_target_list,
6052                             di->source_actions,
6053                             button,
6054                             (GdkEvent*)event);
6055
6056   set_source_row (context, model, path);
6057
6058  out:
6059   if (path)
6060     gtk_tree_path_free (path);
6061
6062   return retval;
6063 }
6064
6065
6066 static void
6067 gtk_tree_view_drag_begin (GtkWidget      *widget,
6068                           GdkDragContext *context)
6069 {
6070   GtkTreeView *tree_view;
6071   GtkTreePath *path = NULL;
6072   gint cell_x, cell_y;
6073   GdkPixmap *row_pix;
6074
6075   tree_view = GTK_TREE_VIEW (widget);
6076
6077   /* if the user uses a custom DnD impl, we don't set the icon here */
6078   if (!get_info (tree_view))
6079     return;
6080
6081   gtk_tree_view_get_path_at_pos (tree_view,
6082                                  tree_view->priv->press_start_x,
6083                                  tree_view->priv->press_start_y,
6084                                  &path,
6085                                  NULL,
6086                                  &cell_x,
6087                                  &cell_y);
6088
6089   g_return_if_fail (path != NULL);
6090
6091   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
6092                                                 path);
6093
6094   gtk_drag_set_icon_pixmap (context,
6095                             gdk_drawable_get_colormap (row_pix),
6096                             row_pix,
6097                             NULL,
6098                             /* the + 1 is for the black border in the icon */
6099                             tree_view->priv->press_start_x + 1,
6100                             cell_y + 1);
6101
6102   g_object_unref (row_pix);
6103   gtk_tree_path_free (path);
6104 }
6105
6106 static void
6107 gtk_tree_view_drag_end (GtkWidget      *widget,
6108                         GdkDragContext *context)
6109 {
6110   /* do nothing */
6111 }
6112
6113 /* Default signal implementations for the drag signals */
6114 static void
6115 gtk_tree_view_drag_data_get (GtkWidget        *widget,
6116                              GdkDragContext   *context,
6117                              GtkSelectionData *selection_data,
6118                              guint             info,
6119                              guint             time)
6120 {
6121   GtkTreeView *tree_view;
6122   GtkTreeModel *model;
6123   TreeViewDragInfo *di;
6124   GtkTreePath *source_row;
6125
6126   tree_view = GTK_TREE_VIEW (widget);
6127
6128   model = gtk_tree_view_get_model (tree_view);
6129
6130   if (model == NULL)
6131     return;
6132
6133   di = get_info (GTK_TREE_VIEW (widget));
6134
6135   if (di == NULL)
6136     return;
6137
6138   source_row = get_source_row (context);
6139
6140   if (source_row == NULL)
6141     return;
6142
6143   /* We can implement the GTK_TREE_MODEL_ROW target generically for
6144    * any model; for DragSource models there are some other targets
6145    * we also support.
6146    */
6147
6148   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
6149       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
6150                                           source_row,
6151                                           selection_data))
6152     goto done;
6153
6154   /* If drag_data_get does nothing, try providing row data. */
6155   if (selection_data->target == gdk_atom_intern ("GTK_TREE_MODEL_ROW", FALSE))
6156     {
6157       gtk_tree_set_row_drag_data (selection_data,
6158                                   model,
6159                                   source_row);
6160     }
6161
6162  done:
6163   gtk_tree_path_free (source_row);
6164 }
6165
6166
6167 static void
6168 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
6169                                 GdkDragContext *context)
6170 {
6171   TreeViewDragInfo *di;
6172   GtkTreeModel *model;
6173   GtkTreeView *tree_view;
6174   GtkTreePath *source_row;
6175
6176   tree_view = GTK_TREE_VIEW (widget);
6177   model = gtk_tree_view_get_model (tree_view);
6178
6179   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
6180     return;
6181
6182   di = get_info (tree_view);
6183
6184   if (di == NULL)
6185     return;
6186
6187   source_row = get_source_row (context);
6188
6189   if (source_row == NULL)
6190     return;
6191
6192   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
6193                                          source_row);
6194
6195   gtk_tree_path_free (source_row);
6196
6197   set_source_row (context, NULL, NULL);
6198 }
6199
6200 static void
6201 gtk_tree_view_drag_leave (GtkWidget      *widget,
6202                           GdkDragContext *context,
6203                           guint             time)
6204 {
6205   TreeViewDragInfo *di;
6206
6207   di = get_info (GTK_TREE_VIEW (widget));
6208
6209   /* unset any highlight row */
6210   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
6211                                    NULL,
6212                                    GTK_TREE_VIEW_DROP_BEFORE);
6213
6214   remove_scroll_timeout (GTK_TREE_VIEW (widget));
6215   remove_open_timeout (GTK_TREE_VIEW (widget));
6216 }
6217
6218
6219 static gboolean
6220 gtk_tree_view_drag_motion (GtkWidget        *widget,
6221                            GdkDragContext   *context,
6222                            gint              x,
6223                            gint              y,
6224                            guint             time)
6225 {
6226   gboolean empty;
6227   GtkTreePath *path = NULL;
6228   GtkTreeModel *model;
6229   GtkTreeViewDropPosition pos;
6230   GtkTreeView *tree_view;
6231   GdkDragAction suggested_action = 0;
6232   GdkAtom target;
6233
6234   tree_view = GTK_TREE_VIEW (widget);
6235
6236   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
6237     return FALSE;
6238
6239   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
6240
6241   /* we only know this *after* set_desination_row */
6242   model = gtk_tree_view_get_model (tree_view);
6243   empty = tree_view->priv->empty_view_drop;
6244
6245   if (path == NULL && !empty)
6246     {
6247       /* Can't drop here. */
6248       gdk_drag_status (context, 0, time);
6249     }
6250   else
6251     {
6252       if (tree_view->priv->open_dest_timeout == 0 &&
6253           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
6254            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
6255         {
6256           tree_view->priv->open_dest_timeout =
6257             g_timeout_add (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
6258         }
6259       else if (tree_view->priv->scroll_timeout == 0)
6260         {
6261           tree_view->priv->scroll_timeout =
6262             g_timeout_add (150, scroll_row_timeout, tree_view);
6263         }
6264
6265       if (target == gdk_atom_intern ("GTK_TREE_MODEL_ROW", FALSE))
6266         {
6267           /* Request data so we can use the source row when
6268            * determining whether to accept the drop
6269            */
6270           set_status_pending (context, suggested_action);
6271           gtk_drag_get_data (widget, context, target, time);
6272         }
6273       else
6274         {
6275           set_status_pending (context, 0);
6276           gdk_drag_status (context, suggested_action, time);
6277         }
6278     }
6279
6280   if (path)
6281     gtk_tree_path_free (path);
6282
6283   return TRUE;
6284 }
6285
6286
6287 static gboolean
6288 gtk_tree_view_drag_drop (GtkWidget        *widget,
6289                          GdkDragContext   *context,
6290                          gint              x,
6291                          gint              y,
6292                          guint             time)
6293 {
6294   GtkTreeView *tree_view;
6295   GtkTreePath *path;
6296   GdkDragAction suggested_action = 0;
6297   GdkAtom target = GDK_NONE;
6298   TreeViewDragInfo *di;
6299   GtkTreeModel *model;
6300   gboolean path_down_mode;
6301   gboolean drop_append_mode;
6302
6303   tree_view = GTK_TREE_VIEW (widget);
6304
6305   model = gtk_tree_view_get_model (tree_view);
6306
6307   remove_scroll_timeout (GTK_TREE_VIEW (widget));
6308   remove_open_timeout (GTK_TREE_VIEW (widget));
6309
6310   di = get_info (tree_view);
6311
6312   if (di == NULL)
6313     return FALSE;
6314
6315   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
6316     return FALSE;
6317
6318   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
6319     return FALSE;
6320
6321   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
6322
6323   if (target != GDK_NONE && path != NULL)
6324     {
6325       /* in case a motion had requested drag data, change things so we
6326        * treat drag data receives as a drop.
6327        */
6328       set_status_pending (context, 0);
6329       set_dest_row (context, model, path,
6330                     path_down_mode, tree_view->priv->empty_view_drop,
6331                     drop_append_mode);
6332     }
6333
6334   if (path)
6335     gtk_tree_path_free (path);
6336
6337   /* Unset this thing */
6338   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
6339                                    NULL,
6340                                    GTK_TREE_VIEW_DROP_BEFORE);
6341
6342   if (target != GDK_NONE)
6343     {
6344       gtk_drag_get_data (widget, context, target, time);
6345       return TRUE;
6346     }
6347   else
6348     return FALSE;
6349 }
6350
6351 static void
6352 gtk_tree_view_drag_data_received (GtkWidget        *widget,
6353                                   GdkDragContext   *context,
6354                                   gint              x,
6355                                   gint              y,
6356                                   GtkSelectionData *selection_data,
6357                                   guint             info,
6358                                   guint             time)
6359 {
6360   GtkTreePath *path;
6361   TreeViewDragInfo *di;
6362   gboolean accepted = FALSE;
6363   GtkTreeModel *model;
6364   GtkTreeView *tree_view;
6365   GtkTreePath *dest_row;
6366   GdkDragAction suggested_action;
6367   gboolean path_down_mode;
6368   gboolean drop_append_mode;
6369
6370   tree_view = GTK_TREE_VIEW (widget);
6371
6372   model = gtk_tree_view_get_model (tree_view);
6373
6374   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
6375     return;
6376
6377   di = get_info (tree_view);
6378
6379   if (di == NULL)
6380     return;
6381
6382   suggested_action = get_status_pending (context);
6383
6384   if (suggested_action)
6385     {
6386       /* We are getting this data due to a request in drag_motion,
6387        * rather than due to a request in drag_drop, so we are just
6388        * supposed to call drag_status, not actually paste in the
6389        * data.
6390        */
6391       path = get_logical_dest_row (tree_view, &path_down_mode,
6392                                    &drop_append_mode);
6393
6394       if (path == NULL)
6395         suggested_action = 0;
6396       else if (path_down_mode)
6397         gtk_tree_path_down (path);
6398
6399       if (suggested_action)
6400         {
6401           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
6402                                                      path,
6403                                                      selection_data))
6404             {
6405               if (path_down_mode)
6406                 {
6407                   path_down_mode = FALSE;
6408                   gtk_tree_path_up (path);
6409
6410                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
6411                                                              path,
6412                                                              selection_data))
6413                     suggested_action = 0;
6414                 }
6415               else
6416                 suggested_action = 0;
6417             }
6418         }
6419
6420       gdk_drag_status (context, suggested_action, time);
6421
6422       if (path)
6423         gtk_tree_path_free (path);
6424
6425       /* If you can't drop, remove user drop indicator until the next motion */
6426       if (suggested_action == 0)
6427         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
6428                                          NULL,
6429                                          GTK_TREE_VIEW_DROP_BEFORE);
6430
6431       return;
6432     }
6433
6434   dest_row = get_dest_row (context, &path_down_mode);
6435
6436   if (dest_row == NULL)
6437     return;
6438
6439   if (selection_data->length >= 0)
6440     {
6441       if (path_down_mode)
6442         {
6443           gtk_tree_path_down (dest_row);
6444           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
6445                                                      dest_row, selection_data))
6446             gtk_tree_path_up (dest_row);
6447         }
6448     }
6449
6450   if (selection_data->length >= 0)
6451     {
6452       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
6453                                                  dest_row,
6454                                                  selection_data))
6455         accepted = TRUE;
6456     }
6457
6458   gtk_drag_finish (context,
6459                    accepted,
6460                    (context->action == GDK_ACTION_MOVE),
6461                    time);
6462
6463   if (gtk_tree_path_get_depth (dest_row) == 1
6464       && gtk_tree_path_get_indices (dest_row)[0] == 0)
6465     {
6466       /* special special case drag to "0", scroll to first item */
6467       if (!tree_view->priv->scroll_to_path)
6468         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
6469     }
6470
6471   gtk_tree_path_free (dest_row);
6472
6473   /* drop dest_row */
6474   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
6475 }
6476
6477
6478
6479 /* GtkContainer Methods
6480  */
6481
6482
6483 static void
6484 gtk_tree_view_remove (GtkContainer *container,
6485                       GtkWidget    *widget)
6486 {
6487   GtkTreeView *tree_view;
6488   GtkTreeViewChild *child = NULL;
6489   GList *tmp_list;
6490
6491   g_return_if_fail (GTK_IS_TREE_VIEW (container));
6492
6493   tree_view = GTK_TREE_VIEW (container);
6494
6495   tmp_list = tree_view->priv->children;
6496   while (tmp_list)
6497     {
6498       child = tmp_list->data;
6499       if (child->widget == widget)
6500         {
6501           gtk_widget_unparent (widget);
6502
6503           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
6504           g_list_free_1 (tmp_list);
6505           g_free (child);
6506           return;
6507         }
6508
6509       tmp_list = tmp_list->next;
6510     }
6511
6512   tmp_list = tree_view->priv->columns;
6513
6514   while (tmp_list)
6515     {
6516       GtkTreeViewColumn *column;
6517       column = tmp_list->data;
6518       if (column->button == widget)
6519         {
6520           gtk_widget_unparent (widget);
6521           return;
6522         }
6523       tmp_list = tmp_list->next;
6524     }
6525 }
6526
6527 static void
6528 gtk_tree_view_forall (GtkContainer *container,
6529                       gboolean      include_internals,
6530                       GtkCallback   callback,
6531                       gpointer      callback_data)
6532 {
6533   GtkTreeView *tree_view;
6534   GtkTreeViewChild *child = NULL;
6535   GtkTreeViewColumn *column;
6536   GList *tmp_list;
6537
6538   g_return_if_fail (GTK_IS_TREE_VIEW (container));
6539   g_return_if_fail (callback != NULL);
6540
6541   tree_view = GTK_TREE_VIEW (container);
6542
6543   tmp_list = tree_view->priv->children;
6544   while (tmp_list)
6545     {
6546       child = tmp_list->data;
6547       tmp_list = tmp_list->next;
6548
6549       (* callback) (child->widget, callback_data);
6550     }
6551   if (include_internals == FALSE)
6552     return;
6553
6554   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
6555     {
6556       column = tmp_list->data;
6557
6558       if (column->button)
6559         (* callback) (column->button, callback_data);
6560     }
6561 }
6562
6563 /* Returns TRUE if the treeview contains no "special" (editable or activatable)
6564  * cells. If so we draw one big row-spanning focus rectangle.
6565  */
6566 static gboolean
6567 gtk_tree_view_has_special_cell (GtkTreeView *tree_view)
6568 {
6569   GList *list;
6570
6571   for (list = tree_view->priv->columns; list; list = list->next)
6572     {
6573       if (!((GtkTreeViewColumn *)list->data)->visible)
6574         continue;
6575       if (_gtk_tree_view_column_count_special_cells (list->data))
6576         return TRUE;
6577     }
6578
6579   return FALSE;
6580 }
6581
6582 static void
6583 column_sizing_notify (GObject    *object,
6584                       GParamSpec *pspec,
6585                       gpointer    data)
6586 {
6587   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
6588
6589   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
6590     /* disable fixed height mode */
6591     g_object_set (data, "fixed-height-mode", FALSE, NULL);
6592 }
6593
6594 /**
6595  * gtk_tree_view_set_fixed_height_mode:
6596  * @tree_view: a #GtkTreeView
6597  * @enable: %TRUE to enable fixed height mode
6598  *
6599  * Enables or disables the fixed height mode of @tree_view.
6600  * Fixed height mode speeds up #GtkTreeView by assuming that all
6601  * rows have the same height.
6602  * Only enable this option if all rows are the same height and all
6603  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
6604  *
6605  * Since: 2.6
6606  **/
6607 void
6608 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
6609                                      gboolean     enable)
6610 {
6611   GList *l;
6612
6613   enable = enable != FALSE;
6614
6615   if (enable == tree_view->priv->fixed_height_mode)
6616     return;
6617
6618   if (!enable)
6619     {
6620       tree_view->priv->fixed_height_mode = 0;
6621       tree_view->priv->fixed_height = -1;
6622
6623       /* force a revalidation */
6624       install_presize_handler (tree_view);
6625     }
6626   else
6627     {
6628       /* make sure all columns are of type FIXED */
6629       for (l = tree_view->priv->columns; l; l = l->next)
6630         {
6631           GtkTreeViewColumn *c = l->data;
6632
6633           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
6634         }
6635
6636       /* yes, we really have to do this is in a separate loop */
6637       for (l = tree_view->priv->columns; l; l = l->next)
6638         g_signal_connect (l->data, "notify::sizing",
6639                           G_CALLBACK (column_sizing_notify), tree_view);
6640
6641       tree_view->priv->fixed_height_mode = 1;
6642       tree_view->priv->fixed_height = -1;
6643
6644       if (tree_view->priv->tree)
6645         initialize_fixed_height_mode (tree_view);
6646     }
6647
6648   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
6649 }
6650
6651 /**
6652  * gtk_tree_view_get_fixed_height_mode:
6653  * @tree_view: a #GtkTreeView
6654  *
6655  * Returns whether fixed height mode is turned on for @tree_view.
6656  *
6657  * Return value: %TRUE if @tree_view is in fixed height mode
6658  *
6659  * Since: 2.6
6660  **/
6661 gboolean
6662 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
6663 {
6664   return tree_view->priv->fixed_height_mode;
6665 }
6666
6667 /* Returns TRUE if the focus is within the headers, after the focus operation is
6668  * done
6669  */
6670 static gboolean
6671 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
6672                             GtkDirectionType  dir)
6673 {
6674   GtkWidget *focus_child;
6675   GtkContainer *container;
6676
6677   GList *last_column, *first_column;
6678   GList *tmp_list;
6679   gboolean rtl;
6680
6681   if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
6682     return FALSE;
6683
6684   focus_child = GTK_CONTAINER (tree_view)->focus_child;
6685   container = GTK_CONTAINER (tree_view);
6686
6687   first_column = tree_view->priv->columns;
6688   while (first_column)
6689     {
6690       if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (first_column->data)->button) &&
6691           GTK_TREE_VIEW_COLUMN (first_column->data)->visible &&
6692           (GTK_TREE_VIEW_COLUMN (first_column->data)->clickable ||
6693            GTK_TREE_VIEW_COLUMN (first_column->data)->reorderable))
6694         break;
6695       first_column = first_column->next;
6696     }
6697
6698   /* No headers are visible, or are focusable.  We can't focus in or out.
6699    */
6700   if (first_column == NULL)
6701     return FALSE;
6702
6703   last_column = g_list_last (tree_view->priv->columns);
6704   while (last_column)
6705     {
6706       if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (last_column->data)->button) &&
6707           GTK_TREE_VIEW_COLUMN (last_column->data)->visible &&
6708           (GTK_TREE_VIEW_COLUMN (last_column->data)->clickable ||
6709            GTK_TREE_VIEW_COLUMN (last_column->data)->reorderable))
6710         break;
6711       last_column = last_column->prev;
6712     }
6713
6714
6715    rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
6716    if (rtl) {
6717      GList *temp = first_column;
6718      first_column = last_column;
6719      last_column = temp;
6720    }
6721
6722   switch (dir)
6723     {
6724     case GTK_DIR_TAB_BACKWARD:
6725     case GTK_DIR_TAB_FORWARD:
6726     case GTK_DIR_UP:
6727     case GTK_DIR_DOWN:
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
6733             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
6734           gtk_widget_grab_focus (focus_child);
6735           break;
6736         }
6737       return FALSE;
6738
6739     case GTK_DIR_LEFT:
6740     case GTK_DIR_RIGHT:
6741       if (focus_child == NULL)
6742         {
6743           if (tree_view->priv->focus_column != NULL)
6744             focus_child = tree_view->priv->focus_column->button;
6745           else if (dir == GTK_DIR_LEFT)
6746             focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
6747           else
6748             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
6749           gtk_widget_grab_focus (focus_child);
6750           break;
6751         }
6752
6753       if (gtk_widget_child_focus (focus_child, dir))
6754         {
6755           /* The focus moves inside the button. */
6756           /* This is probably a great example of bad UI */
6757           break;
6758         }
6759
6760       /* We need to move the focus among the row of buttons. */
6761       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
6762         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
6763           break;
6764
6765       if (tmp_list == first_column && dir == GTK_DIR_LEFT)
6766         {
6767           focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
6768           gtk_widget_grab_focus (focus_child);
6769           break;
6770         }
6771       else if (tmp_list == last_column && dir == GTK_DIR_RIGHT)
6772         {
6773           focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
6774           gtk_widget_grab_focus (focus_child);
6775           break;
6776         }
6777
6778       while (tmp_list)
6779         {
6780           GtkTreeViewColumn *column;
6781
6782           if (dir == GTK_DIR_RIGHT)
6783             tmp_list = tmp_list->next;
6784           else
6785             tmp_list = tmp_list->prev;
6786
6787           if (tmp_list == NULL)
6788             {
6789               g_warning ("Internal button not found");
6790               break;
6791             }
6792           column = tmp_list->data;
6793           if (column->button &&
6794               column->visible &&
6795               GTK_WIDGET_CAN_FOCUS (column->button))
6796             {
6797               focus_child = column->button;
6798               gtk_widget_grab_focus (column->button);
6799               break;
6800             }
6801         }
6802       break;
6803     default:
6804       g_assert_not_reached ();
6805       break;
6806     }
6807
6808   /* if focus child is non-null, we assume it's been set to the current focus child
6809    */
6810   if (focus_child)
6811     {
6812       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
6813         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
6814           break;
6815
6816       tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
6817
6818       /* If the following isn't true, then the view is smaller then the scrollpane.
6819        */
6820       if ((focus_child->allocation.x + focus_child->allocation.width) <=
6821           (tree_view->priv->hadjustment->upper))
6822         {
6823           /* Scroll to the button, if needed */
6824           if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) <
6825               (focus_child->allocation.x + focus_child->allocation.width))
6826             gtk_adjustment_set_value (tree_view->priv->hadjustment,
6827                                       focus_child->allocation.x + focus_child->allocation.width -
6828                                       tree_view->priv->hadjustment->page_size);
6829           else if (tree_view->priv->hadjustment->value > focus_child->allocation.x)
6830             gtk_adjustment_set_value (tree_view->priv->hadjustment,
6831                                       focus_child->allocation.x);
6832         }
6833     }
6834
6835   return (focus_child != NULL);
6836 }
6837
6838 static gint
6839 gtk_tree_view_focus (GtkWidget        *widget,
6840                      GtkDirectionType  direction)
6841 {
6842   GtkTreeView *tree_view;
6843   GtkWidget *focus_child;
6844   GtkContainer *container;
6845
6846   g_return_val_if_fail (GTK_IS_TREE_VIEW (widget), FALSE);
6847   g_return_val_if_fail (GTK_WIDGET_VISIBLE (widget), FALSE);
6848
6849   container = GTK_CONTAINER (widget);
6850   tree_view = GTK_TREE_VIEW (widget);
6851
6852   if (!GTK_WIDGET_IS_SENSITIVE (container))
6853     return FALSE;
6854
6855   focus_child = container->focus_child;
6856
6857   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
6858   /* Case 1.  Headers currently have focus. */
6859   if (focus_child)
6860     {
6861       switch (direction)
6862         {
6863         case GTK_DIR_LEFT:
6864         case GTK_DIR_RIGHT:
6865           gtk_tree_view_header_focus (tree_view, direction);
6866           return TRUE;
6867         case GTK_DIR_TAB_BACKWARD:
6868         case GTK_DIR_UP:
6869           return FALSE;
6870         case GTK_DIR_TAB_FORWARD:
6871         case GTK_DIR_DOWN:
6872           gtk_widget_grab_focus (widget);
6873           return TRUE;
6874         default:
6875           g_assert_not_reached ();
6876           return FALSE;
6877         }
6878     }
6879
6880   /* Case 2. We don't have focus at all. */
6881   if (!GTK_WIDGET_HAS_FOCUS (container))
6882     {
6883       if (!gtk_tree_view_header_focus (tree_view, direction))
6884         gtk_widget_grab_focus (widget);
6885       return TRUE;
6886     }
6887
6888   /* Case 3. We have focus already. */
6889   if (direction == GTK_DIR_TAB_BACKWARD)
6890     return (gtk_tree_view_header_focus (tree_view, direction));
6891   else if (direction == GTK_DIR_TAB_FORWARD)
6892     return FALSE;
6893
6894   /* Other directions caught by the keybindings */
6895   gtk_widget_grab_focus (widget);
6896   return TRUE;
6897 }
6898
6899 static void
6900 gtk_tree_view_grab_focus (GtkWidget *widget)
6901 {
6902   (* GTK_WIDGET_CLASS (parent_class)->grab_focus) (widget);
6903
6904   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
6905 }
6906
6907 static void
6908 gtk_tree_view_style_set (GtkWidget *widget,
6909                          GtkStyle *previous_style)
6910 {
6911   GtkTreeView *tree_view;
6912   GList *list;
6913   GtkTreeViewColumn *column;
6914
6915   g_return_if_fail (GTK_IS_TREE_VIEW (widget));
6916
6917   tree_view = GTK_TREE_VIEW (widget);
6918
6919   if (GTK_WIDGET_REALIZED (widget))
6920     {
6921       gdk_window_set_background (widget->window, &widget->style->base[widget->state]);
6922       gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
6923     }
6924
6925   gtk_widget_style_get (widget,
6926                         "expander-size", &tree_view->priv->expander_size,
6927                         NULL);
6928   tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
6929
6930   for (list = tree_view->priv->columns; list; list = list->next)
6931     {
6932       column = list->data;
6933       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
6934     }
6935
6936   tree_view->priv->fixed_height = -1;
6937   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
6938
6939   gtk_widget_queue_resize (widget);
6940 }
6941
6942
6943 static void
6944 gtk_tree_view_set_focus_child (GtkContainer *container,
6945                                GtkWidget    *child)
6946 {
6947   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
6948   GList *list;
6949
6950   for (list = tree_view->priv->columns; list; list = list->next)
6951     {
6952       if (GTK_TREE_VIEW_COLUMN (list->data)->button == child)
6953         {
6954           tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
6955           break;
6956         }
6957     }
6958
6959   (* parent_class->set_focus_child) (container, child);
6960 }
6961
6962 static void
6963 gtk_tree_view_set_adjustments (GtkTreeView   *tree_view,
6964                                GtkAdjustment *hadj,
6965                                GtkAdjustment *vadj)
6966 {
6967   gboolean need_adjust = FALSE;
6968
6969   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6970
6971   if (hadj)
6972     g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
6973   else
6974     hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
6975   if (vadj)
6976     g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
6977   else
6978     vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
6979
6980   if (tree_view->priv->hadjustment && (tree_view->priv->hadjustment != hadj))
6981     {
6982       g_signal_handlers_disconnect_by_func (tree_view->priv->hadjustment,
6983                                             gtk_tree_view_adjustment_changed,
6984                                             tree_view);
6985       g_object_unref (tree_view->priv->hadjustment);
6986     }
6987
6988   if (tree_view->priv->vadjustment && (tree_view->priv->vadjustment != vadj))
6989     {
6990       g_signal_handlers_disconnect_by_func (tree_view->priv->vadjustment,
6991                                             gtk_tree_view_adjustment_changed,
6992                                             tree_view);
6993       g_object_unref (tree_view->priv->vadjustment);
6994     }
6995
6996   if (tree_view->priv->hadjustment != hadj)
6997     {
6998       tree_view->priv->hadjustment = hadj;
6999       g_object_ref (tree_view->priv->hadjustment);
7000       gtk_object_sink (GTK_OBJECT (tree_view->priv->hadjustment));
7001
7002       g_signal_connect (tree_view->priv->hadjustment, "value_changed",
7003                         G_CALLBACK (gtk_tree_view_adjustment_changed),
7004                         tree_view);
7005       need_adjust = TRUE;
7006     }
7007
7008   if (tree_view->priv->vadjustment != vadj)
7009     {
7010       tree_view->priv->vadjustment = vadj;
7011       g_object_ref (tree_view->priv->vadjustment);
7012       gtk_object_sink (GTK_OBJECT (tree_view->priv->vadjustment));
7013
7014       g_signal_connect (tree_view->priv->vadjustment, "value_changed",
7015                         G_CALLBACK (gtk_tree_view_adjustment_changed),
7016                         tree_view);
7017       need_adjust = TRUE;
7018     }
7019
7020   if (need_adjust)
7021     gtk_tree_view_adjustment_changed (NULL, tree_view);
7022 }
7023
7024
7025 static gboolean
7026 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
7027                                 GtkMovementStep    step,
7028                                 gint               count)
7029 {
7030   GdkModifierType state;
7031
7032   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
7033   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
7034                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
7035                         step == GTK_MOVEMENT_DISPLAY_LINES ||
7036                         step == GTK_MOVEMENT_PAGES ||
7037                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
7038
7039   if (tree_view->priv->tree == NULL)
7040     return FALSE;
7041   if (!GTK_WIDGET_HAS_FOCUS (GTK_WIDGET (tree_view)))
7042     return FALSE;
7043
7044   gtk_tree_view_stop_editing (tree_view, FALSE);
7045   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
7046   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7047
7048   if (gtk_get_current_event_state (&state))
7049     {
7050       if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
7051         tree_view->priv->ctrl_pressed = TRUE;
7052       if ((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
7053         tree_view->priv->shift_pressed = TRUE;
7054     }
7055   /* else we assume not pressed */
7056
7057   switch (step)
7058     {
7059       /* currently we make no distinction.  When we go bi-di, we need to */
7060     case GTK_MOVEMENT_LOGICAL_POSITIONS:
7061     case GTK_MOVEMENT_VISUAL_POSITIONS:
7062       gtk_tree_view_move_cursor_left_right (tree_view, count);
7063       break;
7064     case GTK_MOVEMENT_DISPLAY_LINES:
7065       gtk_tree_view_move_cursor_up_down (tree_view, count);
7066       break;
7067     case GTK_MOVEMENT_PAGES:
7068       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
7069       break;
7070     case GTK_MOVEMENT_BUFFER_ENDS:
7071       gtk_tree_view_move_cursor_start_end (tree_view, count);
7072       break;
7073     default:
7074       g_assert_not_reached ();
7075     }
7076
7077   tree_view->priv->ctrl_pressed = FALSE;
7078   tree_view->priv->shift_pressed = FALSE;
7079
7080   return TRUE;
7081 }
7082
7083 static void
7084 gtk_tree_view_put (GtkTreeView *tree_view,
7085                    GtkWidget   *child_widget,
7086                    gint         x,
7087                    gint         y,
7088                    gint         width,
7089                    gint         height)
7090 {
7091   GtkTreeViewChild *child;
7092
7093   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7094   g_return_if_fail (GTK_IS_WIDGET (child_widget));
7095
7096   child = g_new (GtkTreeViewChild, 1);
7097
7098   child->widget = child_widget;
7099   child->x = x;
7100   child->y = y;
7101   child->width = width;
7102   child->height = height;
7103
7104   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
7105
7106   if (GTK_WIDGET_REALIZED (tree_view))
7107     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
7108
7109   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
7110 }
7111
7112 void
7113 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
7114                                   GtkWidget   *widget,
7115                                   gint         x,
7116                                   gint         y,
7117                                   gint         width,
7118                                   gint         height)
7119 {
7120   GtkTreeViewChild *child = NULL;
7121   GList *list;
7122   GdkRectangle allocation;
7123
7124   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
7125   g_return_if_fail (GTK_IS_WIDGET (widget));
7126
7127   for (list = tree_view->priv->children; list; list = list->next)
7128     {
7129       if (((GtkTreeViewChild *)list->data)->widget == widget)
7130         {
7131           child = list->data;
7132           break;
7133         }
7134     }
7135   if (child == NULL)
7136     return;
7137
7138   allocation.x = child->x = x;
7139   allocation.y = child->y = y;
7140   allocation.width = child->width = width;
7141   allocation.height = child->height = height;
7142
7143   if (GTK_WIDGET_REALIZED (widget))
7144     gtk_widget_size_allocate (widget, &allocation);
7145 }
7146
7147
7148 /* TreeModel Callbacks
7149  */
7150
7151 static void
7152 gtk_tree_view_row_changed (GtkTreeModel *model,
7153                            GtkTreePath  *path,
7154                            GtkTreeIter  *iter,
7155                            gpointer      data)
7156 {
7157   GtkTreeView *tree_view = (GtkTreeView *)data;
7158   GtkRBTree *tree;
7159   GtkRBNode *node;
7160   gboolean free_path = FALSE;
7161   gint vertical_separator;
7162   GList *list;
7163   GtkTreePath *cursor_path;
7164
7165   g_return_if_fail (path != NULL || iter != NULL);
7166
7167   if (!GTK_WIDGET_REALIZED (tree_view))
7168     /* We can just ignore ::changed signals if we aren't realized, as we don't care about sizes
7169      */
7170     return;
7171
7172   if (tree_view->priv->cursor != NULL)
7173     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7174   else
7175     cursor_path = NULL;
7176
7177   if (tree_view->priv->edited_column &&
7178       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
7179     gtk_tree_view_stop_editing (tree_view, TRUE);
7180
7181   if (cursor_path != NULL)
7182     gtk_tree_path_free (cursor_path);
7183
7184   gtk_widget_style_get (GTK_WIDGET (data), "vertical-separator", &vertical_separator, NULL);
7185
7186   if (path == NULL)
7187     {
7188       path = gtk_tree_model_get_path (model, iter);
7189       free_path = TRUE;
7190     }
7191   else if (iter == NULL)
7192     gtk_tree_model_get_iter (model, iter, path);
7193
7194   if (_gtk_tree_view_find_node (tree_view,
7195                                 path,
7196                                 &tree,
7197                                 &node))
7198     /* We aren't actually showing the node */
7199     goto done;
7200
7201   if (tree == NULL)
7202     goto done;
7203
7204   if (tree_view->priv->fixed_height_mode
7205       && tree_view->priv->fixed_height >= 0)
7206     {
7207       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
7208       gtk_tree_view_node_queue_redraw (tree_view, tree, node);
7209     }
7210   else
7211     {
7212       _gtk_rbtree_node_mark_invalid (tree, node);
7213       for (list = tree_view->priv->columns; list; list = list->next)
7214         {
7215           GtkTreeViewColumn *column;
7216
7217           column = list->data;
7218           if (! column->visible)
7219             continue;
7220
7221           if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
7222             {
7223               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
7224             }
7225         }
7226     }
7227
7228  done:
7229   if (!tree_view->priv->fixed_height_mode)
7230     install_presize_handler (tree_view);
7231   if (free_path)
7232     gtk_tree_path_free (path);
7233 }
7234
7235 static void
7236 gtk_tree_view_row_inserted (GtkTreeModel *model,
7237                             GtkTreePath  *path,
7238                             GtkTreeIter  *iter,
7239                             gpointer      data)
7240 {
7241   GtkTreeView *tree_view = (GtkTreeView *) data;
7242   gint *indices;
7243   GtkRBTree *tmptree, *tree;
7244   GtkRBNode *tmpnode = NULL;
7245   gint depth;
7246   gint i = 0;
7247   gint height;
7248   gboolean free_path = FALSE;
7249
7250   g_return_if_fail (path != NULL || iter != NULL);
7251
7252   if (tree_view->priv->fixed_height_mode
7253       && tree_view->priv->fixed_height >= 0)
7254     height = tree_view->priv->fixed_height;
7255   else
7256     height = 0;
7257
7258   if (path == NULL)
7259     {
7260       path = gtk_tree_model_get_path (model, iter);
7261       free_path = TRUE;
7262     }
7263   else if (iter == NULL)
7264     gtk_tree_model_get_iter (model, iter, path);
7265
7266   if (tree_view->priv->tree == NULL)
7267     tree_view->priv->tree = _gtk_rbtree_new ();
7268
7269   tmptree = tree = tree_view->priv->tree;
7270
7271   /* Update all row-references */
7272   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
7273   depth = gtk_tree_path_get_depth (path);
7274   indices = gtk_tree_path_get_indices (path);
7275
7276   /* First, find the parent tree */
7277   while (i < depth - 1)
7278     {
7279       if (tmptree == NULL)
7280         {
7281           /* We aren't showing the node */
7282           goto done;
7283         }
7284
7285       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
7286       if (tmpnode == NULL)
7287         {
7288           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
7289                      "This possibly means that a GtkTreeModel inserted a child node\n" \
7290                      "before the parent was inserted.");
7291           goto done;
7292         }
7293       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
7294         {
7295           /* FIXME enforce correct behavior on model, probably */
7296           /* In theory, the model should have emitted has_child_toggled here.  We
7297            * try to catch it anyway, just to be safe, in case the model hasn't.
7298            */
7299           GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
7300                                                            tree,
7301                                                            tmpnode);
7302           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
7303           gtk_tree_path_free (tmppath);
7304           goto done;
7305         }
7306
7307       tmptree = tmpnode->children;
7308       tree = tmptree;
7309       i++;
7310     }
7311
7312   if (tree == NULL)
7313     goto done;
7314
7315   /* ref the node */
7316   gtk_tree_model_ref_node (tree_view->priv->model, iter);
7317   if (indices[depth - 1] == 0)
7318     {
7319       tmpnode = _gtk_rbtree_find_count (tree, 1);
7320       _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
7321     }
7322   else
7323     {
7324       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
7325       _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
7326     }
7327
7328  done:
7329   if (height > 0)
7330     {
7331       if (tree)
7332         _gtk_rbtree_node_mark_valid (tree, tmpnode);
7333       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
7334     }
7335   else
7336     install_presize_handler (tree_view);
7337   if (free_path)
7338     gtk_tree_path_free (path);
7339 }
7340
7341 static void
7342 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
7343                                      GtkTreePath  *path,
7344                                      GtkTreeIter  *iter,
7345                                      gpointer      data)
7346 {
7347   GtkTreeView *tree_view = (GtkTreeView *)data;
7348   GtkTreeIter real_iter;
7349   gboolean has_child;
7350   GtkRBTree *tree;
7351   GtkRBNode *node;
7352   gboolean free_path = FALSE;
7353
7354   g_return_if_fail (path != NULL || iter != NULL);
7355
7356   if (iter)
7357     real_iter = *iter;
7358
7359   if (path == NULL)
7360     {
7361       path = gtk_tree_model_get_path (model, iter);
7362       free_path = TRUE;
7363     }
7364   else if (iter == NULL)
7365     gtk_tree_model_get_iter (model, &real_iter, path);
7366
7367   if (_gtk_tree_view_find_node (tree_view,
7368                                 path,
7369                                 &tree,
7370                                 &node))
7371     /* We aren't actually showing the node */
7372     goto done;
7373
7374   if (tree == NULL)
7375     goto done;
7376
7377   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
7378   /* Sanity check.
7379    */
7380   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
7381     goto done;
7382
7383   if (has_child)
7384     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
7385   else
7386     GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
7387
7388   if (has_child && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
7389     {
7390       GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
7391       if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS))
7392         {
7393           GList *list;
7394
7395           for (list = tree_view->priv->columns; list; list = list->next)
7396             if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
7397               {
7398                 GTK_TREE_VIEW_COLUMN (list->data)->dirty = TRUE;
7399                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
7400                 break;
7401               }
7402         }
7403       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
7404     }
7405   else
7406     {
7407       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
7408     }
7409
7410  done:
7411   if (free_path)
7412     gtk_tree_path_free (path);
7413 }
7414
7415 static void
7416 count_children_helper (GtkRBTree *tree,
7417                        GtkRBNode *node,
7418                        gpointer   data)
7419 {
7420   if (node->children)
7421     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
7422   (*((gint *)data))++;
7423 }
7424
7425 static void
7426 check_selection_helper (GtkRBTree *tree,
7427                         GtkRBNode *node,
7428                         gpointer   data)
7429 {
7430   gint *value = (gint *)data;
7431
7432   *value = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
7433
7434   if (node->children && !*value)
7435     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
7436 }
7437
7438 static void
7439 gtk_tree_view_row_deleted (GtkTreeModel *model,
7440                            GtkTreePath  *path,
7441                            gpointer      data)
7442 {
7443   GtkTreeView *tree_view = (GtkTreeView *)data;
7444   GtkRBTree *tree;
7445   GtkRBNode *node;
7446   GList *list;
7447   gint selection_changed = FALSE;
7448
7449   g_return_if_fail (path != NULL);
7450
7451   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
7452
7453   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
7454     return;
7455
7456   if (tree == NULL)
7457     return;
7458
7459   /* check if the selection has been changed */
7460   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
7461                         check_selection_helper, &selection_changed);
7462
7463   for (list = tree_view->priv->columns; list; list = list->next)
7464     if (((GtkTreeViewColumn *)list->data)->visible &&
7465         ((GtkTreeViewColumn *)list->data)->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
7466       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
7467
7468   /* Ensure we don't have a dangling pointer to a dead node */
7469   ensure_unprelighted (tree_view);
7470
7471   /* Cancel editting if we've started */
7472   gtk_tree_view_stop_editing (tree_view, TRUE);
7473
7474   /* If we have a node expanded/collapsed timeout, remove it */
7475   if (tree_view->priv->expand_collapse_timeout != 0)
7476     {
7477       g_source_remove (tree_view->priv->expand_collapse_timeout);
7478       tree_view->priv->expand_collapse_timeout = 0;
7479
7480       /* Reset node */
7481       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_COLLAPSED);
7482       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_EXPANDED);
7483       tree_view->priv->expanded_collapsed_node = NULL;
7484     }
7485
7486   if (tree_view->priv->destroy_count_func)
7487     {
7488       gint child_count = 0;
7489       if (node->children)
7490         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
7491       (* tree_view->priv->destroy_count_func) (tree_view, path, child_count, tree_view->priv->destroy_count_data);
7492     }
7493
7494   if (tree->root->count == 1)
7495     {
7496       if (tree_view->priv->tree == tree)
7497         tree_view->priv->tree = NULL;
7498
7499       _gtk_rbtree_remove (tree);
7500     }
7501   else
7502     {
7503       _gtk_rbtree_remove_node (tree, node);
7504     }
7505
7506   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
7507     {
7508       gtk_tree_row_reference_free (tree_view->priv->top_row);
7509       tree_view->priv->top_row = NULL;
7510     }
7511
7512   install_scroll_sync_handler (tree_view);
7513
7514   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
7515
7516   if (selection_changed)
7517     g_signal_emit_by_name (tree_view->priv->selection, "changed");
7518 }
7519
7520 static void
7521 cancel_arrow_animation (GtkTreeView *tree_view)
7522 {
7523   if (tree_view->priv->expand_collapse_timeout)
7524     {
7525       while (do_expand_collapse (tree_view));
7526
7527       g_source_remove (tree_view->priv->expand_collapse_timeout);
7528       tree_view->priv->expand_collapse_timeout = 0;
7529     }
7530 }
7531
7532 static void
7533 gtk_tree_view_rows_reordered (GtkTreeModel *model,
7534                               GtkTreePath  *parent,
7535                               GtkTreeIter  *iter,
7536                               gint         *new_order,
7537                               gpointer      data)
7538 {
7539   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
7540   GtkRBTree *tree;
7541   GtkRBNode *node;
7542   gint len;
7543
7544   len = gtk_tree_model_iter_n_children (model, iter);
7545
7546   if (len < 2)
7547     return;
7548
7549   gtk_tree_row_reference_reordered (G_OBJECT (data),
7550                                     parent,
7551                                     iter,
7552                                     new_order);
7553
7554   if (_gtk_tree_view_find_node (tree_view,
7555                                 parent,
7556                                 &tree,
7557                                 &node))
7558     return;
7559
7560   /* We need to special case the parent path */
7561   if (tree == NULL)
7562     tree = tree_view->priv->tree;
7563   else
7564     tree = node->children;
7565
7566   if (tree == NULL)
7567     return;
7568
7569   if (tree_view->priv->edited_column)
7570     gtk_tree_view_stop_editing (tree_view, TRUE);
7571
7572   /* we need to be unprelighted */
7573   ensure_unprelighted (tree_view);
7574
7575   /* clear the timeout */
7576   cancel_arrow_animation (tree_view);
7577
7578   _gtk_rbtree_reorder (tree, new_order, len);
7579
7580   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
7581
7582   gtk_tree_view_dy_to_top_row (tree_view);
7583 }
7584
7585
7586 /* Internal tree functions
7587  */
7588
7589
7590 static void
7591 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
7592                                      GtkRBTree         *tree,
7593                                      GtkTreeViewColumn *column,
7594                                      gint              *x1,
7595                                      gint              *x2)
7596 {
7597   GtkTreeViewColumn *tmp_column = NULL;
7598   gint total_width;
7599   GList *list;
7600   gboolean rtl;
7601
7602   if (x1)
7603     *x1 = 0;
7604
7605   if (x2)
7606     *x2 = 0;
7607
7608   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
7609
7610   total_width = 0;
7611   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
7612        list;
7613        list = (rtl ? list->prev : list->next))
7614     {
7615       tmp_column = list->data;
7616
7617       if (tmp_column == column)
7618         break;
7619
7620       if (tmp_column->visible)
7621         total_width += tmp_column->width;
7622     }
7623
7624   if (tmp_column != column)
7625     {
7626       g_warning (G_STRLOC": passed-in column isn't in the tree");
7627       return;
7628     }
7629
7630   if (x1)
7631     *x1 = total_width;
7632
7633   if (x2)
7634     {
7635       if (column->visible)
7636         *x2 = total_width + column->width;
7637       else
7638         *x2 = total_width; /* width of 0 */
7639     }
7640 }
7641 static void
7642 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
7643                                 GtkRBTree   *tree,
7644                                 gint        *x1,
7645                                 gint        *x2)
7646 {
7647   gint x_offset = 0;
7648   GList *list;
7649   GtkTreeViewColumn *tmp_column = NULL;
7650   gint total_width;
7651   gboolean indent_expanders;
7652   gboolean rtl;
7653
7654   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
7655
7656   total_width = 0;
7657   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
7658        list;
7659        list = (rtl ? list->prev : list->next))
7660     {
7661       tmp_column = list->data;
7662
7663       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
7664         {
7665           if (rtl)
7666             x_offset = total_width + tmp_column->width - tree_view->priv->expander_size;
7667           else
7668             x_offset = total_width;
7669           break;
7670         }
7671
7672       if (tmp_column->visible)
7673         total_width += tmp_column->width;
7674     }
7675
7676   gtk_widget_style_get (GTK_WIDGET (tree_view),
7677                         "indent-expanders", &indent_expanders,
7678                         NULL);
7679
7680   if (indent_expanders)
7681     {
7682       if (rtl)
7683         x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
7684       else
7685         x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
7686     }
7687   if (x1)
7688     {
7689       *x1 = x_offset;
7690     }
7691
7692   if (tmp_column && tmp_column->visible)
7693     {
7694       /* +1 because x2 isn't included in the range. */
7695       if (x2)
7696         *x2 = *x1 + tree_view->priv->expander_size + 1;
7697     }
7698   else
7699     {
7700       /* return an empty range, the expander column is hidden */
7701       if (x2)
7702         *x2 = *x1;
7703     }
7704 }
7705
7706 static void
7707 gtk_tree_view_build_tree (GtkTreeView *tree_view,
7708                           GtkRBTree   *tree,
7709                           GtkTreeIter *iter,
7710                           gint         depth,
7711                           gboolean     recurse)
7712 {
7713   GtkRBNode *temp = NULL;
7714   gboolean is_list = GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST);
7715
7716   do
7717     {
7718       gtk_tree_model_ref_node (tree_view->priv->model, iter);
7719       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
7720
7721       if (tree_view->priv->fixed_height > 0)
7722         {
7723           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
7724             {
7725               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
7726               _gtk_rbtree_node_mark_valid (tree, temp);
7727             }
7728         }
7729
7730       if (is_list)
7731         continue;
7732
7733       if (recurse)
7734         {
7735           GtkTreeIter child;
7736
7737           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
7738             {
7739               temp->children = _gtk_rbtree_new ();
7740               temp->children->parent_tree = tree;
7741               temp->children->parent_node = temp;
7742               gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
7743             }
7744         }
7745       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
7746         {
7747           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
7748             temp->flags ^= GTK_RBNODE_IS_PARENT;
7749         }
7750     }
7751   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
7752 }
7753
7754 /* If height is non-NULL, then we set it to be the new height.  if it's all
7755  * dirty, then height is -1.  We know we'll remeasure dirty rows, anyways.
7756  */
7757 static gboolean
7758 gtk_tree_view_discover_dirty_iter (GtkTreeView *tree_view,
7759                                    GtkTreeIter *iter,
7760                                    gint         depth,
7761                                    gint        *height,
7762                                    GtkRBNode   *node)
7763 {
7764   GtkTreeViewColumn *column;
7765   GList *list;
7766   gboolean retval = FALSE;
7767   gint tmpheight;
7768   gint horizontal_separator;
7769
7770   gtk_widget_style_get (GTK_WIDGET (tree_view),
7771                         "horizontal-separator", &horizontal_separator,
7772                         NULL);
7773
7774   if (height)
7775     *height = -1;
7776
7777   for (list = tree_view->priv->columns; list; list = list->next)
7778     {
7779       gint width;
7780       column = list->data;
7781       if (column->dirty == TRUE)
7782         continue;
7783       if (height == NULL && column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
7784         continue;
7785       if (!column->visible)
7786         continue;
7787
7788       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
7789                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
7790                                                node->children?TRUE:FALSE);
7791
7792       if (height)
7793         {
7794           gtk_tree_view_column_cell_get_size (column,
7795                                               NULL, NULL, NULL,
7796                                               &width, &tmpheight);
7797           *height = MAX (*height, tmpheight);
7798         }
7799       else
7800         {
7801           gtk_tree_view_column_cell_get_size (column,
7802                                               NULL, NULL, NULL,
7803                                               &width, NULL);
7804         }
7805
7806       if (gtk_tree_view_is_expander_column (tree_view, column) &&
7807           TREE_VIEW_DRAW_EXPANDERS (tree_view))
7808         {
7809           if (depth * tree_view->priv->expander_size + horizontal_separator + width > column->requested_width)
7810             {
7811               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
7812               retval = TRUE;
7813             }
7814         }
7815       else
7816         {
7817           if (horizontal_separator + width > column->requested_width)
7818             {
7819               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
7820               retval = TRUE;
7821             }
7822         }
7823     }
7824
7825   return retval;
7826 }
7827
7828 static void
7829 gtk_tree_view_discover_dirty (GtkTreeView *tree_view,
7830                               GtkRBTree   *tree,
7831                               GtkTreeIter *iter,
7832                               gint         depth)
7833 {
7834   GtkRBNode *temp = tree->root;
7835   GtkTreeViewColumn *column;
7836   GList *list;
7837   GtkTreeIter child;
7838   gboolean is_all_dirty;
7839
7840   TREE_VIEW_INTERNAL_ASSERT_VOID (tree != NULL);
7841
7842   while (temp->left != tree->nil)
7843     temp = temp->left;
7844
7845   do
7846     {
7847       TREE_VIEW_INTERNAL_ASSERT_VOID (temp != NULL);
7848       is_all_dirty = TRUE;
7849       for (list = tree_view->priv->columns; list; list = list->next)
7850         {
7851           column = list->data;
7852           if (column->dirty == FALSE)
7853             {
7854               is_all_dirty = FALSE;
7855               break;
7856             }
7857         }
7858
7859       if (is_all_dirty)
7860         return;
7861
7862       gtk_tree_view_discover_dirty_iter (tree_view,
7863                                          iter,
7864                                          depth,
7865                                          NULL,
7866                                          temp);
7867       if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter) &&
7868           temp->children != NULL)
7869         gtk_tree_view_discover_dirty (tree_view, temp->children, &child, depth + 1);
7870       temp = _gtk_rbtree_next (tree, temp);
7871     }
7872   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
7873 }
7874
7875
7876 /* Make sure the node is visible vertically */
7877 static void
7878 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
7879                                   GtkRBTree   *tree,
7880                                   GtkRBNode   *node)
7881 {
7882   gint node_dy, height;
7883   GtkTreePath *path = NULL;
7884
7885   if (!GTK_WIDGET_REALIZED (tree_view))
7886     return;
7887
7888   /* just return if the node is visible, avoiding a costly expose */
7889   node_dy = _gtk_rbtree_node_find_offset (tree, node);
7890   height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
7891   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
7892       && node_dy >= tree_view->priv->vadjustment->value
7893       && node_dy + height <= (tree_view->priv->vadjustment->value
7894                               + tree_view->priv->vadjustment->page_size))
7895     return;
7896
7897   path = _gtk_tree_view_find_path (tree_view, tree, node);
7898   if (path)
7899     {
7900       /* We process updates because we want to clear old selected items when we scroll.
7901        * if this is removed, we get a "selection streak" at the bottom. */
7902       gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
7903       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
7904       gtk_tree_path_free (path);
7905     }
7906 }
7907
7908 static void
7909 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
7910                                     GtkTreeViewColumn *column)
7911 {
7912   if (column == NULL)
7913     return;
7914   if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) <
7915       (column->button->allocation.x + column->button->allocation.width))
7916     gtk_adjustment_set_value (tree_view->priv->hadjustment,
7917                               column->button->allocation.x + column->button->allocation.width -
7918                               tree_view->priv->hadjustment->page_size);
7919   else if (tree_view->priv->hadjustment->value > column->button->allocation.x)
7920     gtk_adjustment_set_value (tree_view->priv->hadjustment,
7921                               column->button->allocation.x);
7922 }
7923
7924 /* This function could be more efficient.  I'll optimize it if profiling seems
7925  * to imply that it is important */
7926 GtkTreePath *
7927 _gtk_tree_view_find_path (GtkTreeView *tree_view,
7928                           GtkRBTree   *tree,
7929                           GtkRBNode   *node)
7930 {
7931   GtkTreePath *path;
7932   GtkRBTree *tmp_tree;
7933   GtkRBNode *tmp_node, *last;
7934   gint count;
7935
7936   path = gtk_tree_path_new ();
7937
7938   g_return_val_if_fail (node != NULL, path);
7939   g_return_val_if_fail (node != tree->nil, path);
7940
7941   count = 1 + node->left->count;
7942
7943   last = node;
7944   tmp_node = node->parent;
7945   tmp_tree = tree;
7946   while (tmp_tree)
7947     {
7948       while (tmp_node != tmp_tree->nil)
7949         {
7950           if (tmp_node->right == last)
7951             count += 1 + tmp_node->left->count;
7952           last = tmp_node;
7953           tmp_node = tmp_node->parent;
7954         }
7955       gtk_tree_path_prepend_index (path, count - 1);
7956       last = tmp_tree->parent_node;
7957       tmp_tree = tmp_tree->parent_tree;
7958       if (last)
7959         {
7960           count = 1 + last->left->count;
7961           tmp_node = last->parent;
7962         }
7963     }
7964   return path;
7965 }
7966
7967 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
7968  * invalid (ie. points to a node that's not in the tree), *tree and *node are
7969  * both set to NULL.
7970  */
7971 gboolean
7972 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
7973                           GtkTreePath  *path,
7974                           GtkRBTree   **tree,
7975                           GtkRBNode   **node)
7976 {
7977   GtkRBNode *tmpnode = NULL;
7978   GtkRBTree *tmptree = tree_view->priv->tree;
7979   gint *indices = gtk_tree_path_get_indices (path);
7980   gint depth = gtk_tree_path_get_depth (path);
7981   gint i = 0;
7982
7983   *node = NULL;
7984   *tree = NULL;
7985
7986   if (depth == 0 || tmptree == NULL)
7987     return FALSE;
7988   do
7989     {
7990       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
7991       ++i;
7992       if (tmpnode == NULL)
7993         {
7994           *tree = NULL;
7995           *node = NULL;
7996           return FALSE;
7997         }
7998       if (i >= depth)
7999         {
8000           *tree = tmptree;
8001           *node = tmpnode;
8002           return FALSE;
8003         }
8004       *tree = tmptree;
8005       *node = tmpnode;
8006       tmptree = tmpnode->children;
8007       if (tmptree == NULL)
8008         return TRUE;
8009     }
8010   while (1);
8011 }
8012
8013 static gboolean
8014 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
8015                                   GtkTreeViewColumn *column)
8016 {
8017   GList *list;
8018
8019   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
8020     return FALSE;
8021
8022   if (tree_view->priv->expander_column != NULL)
8023     {
8024       if (tree_view->priv->expander_column == column)
8025         return TRUE;
8026       return FALSE;
8027     }
8028   else
8029     {
8030       for (list = tree_view->priv->columns;
8031            list;
8032            list = list->next)
8033         if (((GtkTreeViewColumn *)list->data)->visible)
8034           break;
8035       if (list && list->data == column)
8036         return TRUE;
8037     }
8038   return FALSE;
8039 }
8040
8041 static void
8042 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
8043                                 guint           keyval,
8044                                 guint           modmask,
8045                                 GtkMovementStep step,
8046                                 gint            count)
8047 {
8048
8049   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
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_SHIFT_MASK,
8055                                 "move_cursor", 2,
8056                                 G_TYPE_ENUM, step,
8057                                 G_TYPE_INT, count);
8058
8059   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
8060    return;
8061
8062   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
8063                                 "move_cursor", 2,
8064                                 G_TYPE_ENUM, step,
8065                                 G_TYPE_INT, count);
8066
8067   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
8068                                 "move_cursor", 2,
8069                                 G_TYPE_ENUM, step,
8070                                 G_TYPE_INT, count);
8071 }
8072
8073 static gint
8074 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
8075                                  GtkTreeIter  *iter,
8076                                  GtkRBTree    *tree,
8077                                  GtkRBNode    *node)
8078 {
8079   gint retval = FALSE;
8080   do
8081     {
8082       g_return_val_if_fail (node != NULL, FALSE);
8083
8084       if (node->children)
8085         {
8086           GtkTreeIter child;
8087           GtkRBTree *new_tree;
8088           GtkRBNode *new_node;
8089
8090           new_tree = node->children;
8091           new_node = new_tree->root;
8092
8093           while (new_node && new_node->left != new_tree->nil)
8094             new_node = new_node->left;
8095
8096           if (!gtk_tree_model_iter_children (model, &child, iter))
8097             return FALSE;
8098
8099           retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
8100         }
8101
8102       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
8103         retval = TRUE;
8104       gtk_tree_model_unref_node (model, iter);
8105       node = _gtk_rbtree_next (tree, node);
8106     }
8107   while (gtk_tree_model_iter_next (model, iter));
8108
8109   return retval;
8110 }
8111
8112 static gint
8113 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
8114                                               GtkRBTree   *tree)
8115 {
8116   GtkTreeIter iter;
8117   GtkTreePath *path;
8118   GtkRBNode *node;
8119   gint retval;
8120
8121   if (!tree)
8122     return FALSE;
8123
8124   node = tree->root;
8125   while (node && node->left != tree->nil)
8126     node = node->left;
8127
8128   g_return_val_if_fail (node != NULL, FALSE);
8129   path = _gtk_tree_view_find_path (tree_view, tree, node);
8130   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
8131                            &iter, path);
8132   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
8133   gtk_tree_path_free (path);
8134
8135   return retval;
8136 }
8137
8138 static void
8139 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
8140                                     GtkTreeViewColumn *column)
8141 {
8142   GtkTreeViewColumn *left_column;
8143   GtkTreeViewColumn *cur_column = NULL;
8144   GtkTreeViewColumnReorder *reorder;
8145   gboolean rtl;
8146   GList *tmp_list;
8147   gint left;
8148
8149   /* We want to precalculate the motion list such that we know what column slots
8150    * are available.
8151    */
8152   left_column = NULL;
8153   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8154
8155   /* First, identify all possible drop spots */
8156   if (rtl)
8157     tmp_list = g_list_last (tree_view->priv->columns);
8158   else
8159     tmp_list = g_list_first (tree_view->priv->columns);
8160
8161   while (tmp_list)
8162     {
8163       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
8164       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
8165
8166       if (cur_column->visible == FALSE)
8167         continue;
8168
8169       /* If it's not the column moving and func tells us to skip over the column, we continue. */
8170       if (left_column != column && cur_column != column &&
8171           tree_view->priv->column_drop_func &&
8172           ! (* tree_view->priv->column_drop_func) (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
8173         {
8174           left_column = cur_column;
8175           continue;
8176         }
8177       reorder = g_new (GtkTreeViewColumnReorder, 1);
8178       reorder->left_column = left_column;
8179       left_column = reorder->right_column = cur_column;
8180
8181       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
8182     }
8183
8184   /* Add the last one */
8185   if (tree_view->priv->column_drop_func == NULL ||
8186       ((left_column != column) &&
8187        (* tree_view->priv->column_drop_func) (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
8188     {
8189       reorder = g_new (GtkTreeViewColumnReorder, 1);
8190       reorder->left_column = left_column;
8191       reorder->right_column = NULL;
8192       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
8193     }
8194
8195   /* We quickly check to see if it even makes sense to reorder columns. */
8196   /* If there is nothing that can be moved, then we return */
8197
8198   if (tree_view->priv->column_drag_info == NULL)
8199     return;
8200
8201   /* We know there are always 2 slots possbile, as you can always return column. */
8202   /* If that's all there is, return */
8203   if (tree_view->priv->column_drag_info->next->next == NULL &&
8204       ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
8205       ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column)
8206     {
8207       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
8208         g_free (tmp_list->data);
8209       g_list_free (tree_view->priv->column_drag_info);
8210       tree_view->priv->column_drag_info = NULL;
8211       return;
8212     }
8213   /* We fill in the ranges for the columns, now that we've isolated them */
8214   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
8215
8216   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
8217     {
8218       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
8219
8220       reorder->left_align = left;
8221       if (tmp_list->next != NULL)
8222         {
8223           g_assert (tmp_list->next->data);
8224           left = reorder->right_align = (reorder->right_column->button->allocation.x +
8225                                          reorder->right_column->button->allocation.width +
8226                                          ((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column->button->allocation.x)/2;
8227         }
8228       else
8229         {
8230           gint width;
8231
8232           gdk_drawable_get_size (tree_view->priv->header_window, &width, NULL);
8233           reorder->right_align = width + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
8234         }
8235     }
8236 }
8237
8238 void
8239 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
8240                                   GtkTreeViewColumn *column)
8241 {
8242   GdkEvent *send_event;
8243   GtkAllocation allocation;
8244   gint x, y, width, height;
8245   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
8246   GdkDisplay *display = gdk_screen_get_display (screen);
8247
8248   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
8249   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
8250
8251   gtk_tree_view_set_column_drag_info (tree_view, column);
8252
8253   if (tree_view->priv->column_drag_info == NULL)
8254     return;
8255
8256   if (tree_view->priv->drag_window == NULL)
8257     {
8258       GdkWindowAttr attributes;
8259       guint attributes_mask;
8260
8261       attributes.window_type = GDK_WINDOW_CHILD;
8262       attributes.wclass = GDK_INPUT_OUTPUT;
8263       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
8264       attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
8265       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
8266       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
8267
8268       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
8269                                                      &attributes,
8270                                                      attributes_mask);
8271       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
8272     }
8273
8274   gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
8275   gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
8276
8277   gtk_grab_remove (column->button);
8278
8279   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
8280   send_event->crossing.send_event = TRUE;
8281   send_event->crossing.window = g_object_ref (GTK_BUTTON (column->button)->event_window);
8282   send_event->crossing.subwindow = NULL;
8283   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
8284   send_event->crossing.time = GDK_CURRENT_TIME;
8285
8286   gtk_propagate_event (column->button, send_event);
8287   gdk_event_free (send_event);
8288
8289   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
8290   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
8291   send_event->button.send_event = TRUE;
8292   send_event->button.time = GDK_CURRENT_TIME;
8293   send_event->button.x = -1;
8294   send_event->button.y = -1;
8295   send_event->button.axes = NULL;
8296   send_event->button.state = 0;
8297   send_event->button.button = 1;
8298   send_event->button.device = gdk_display_get_core_pointer (display);
8299   send_event->button.x_root = 0;
8300   send_event->button.y_root = 0;
8301
8302   gtk_propagate_event (column->button, send_event);
8303   gdk_event_free (send_event);
8304
8305   gdk_window_move_resize (tree_view->priv->drag_window,
8306                           column->button->allocation.x,
8307                           0,
8308                           column->button->allocation.width,
8309                           column->button->allocation.height);
8310
8311   /* Kids, don't try this at home */
8312   g_object_ref (column->button);
8313   gtk_container_remove (GTK_CONTAINER (tree_view), column->button);
8314   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
8315   gtk_widget_set_parent (column->button, GTK_WIDGET (tree_view));
8316   g_object_unref (column->button);
8317
8318   tree_view->priv->drag_column_x = column->button->allocation.x;
8319   allocation = column->button->allocation;
8320   allocation.x = 0;
8321   gtk_widget_size_allocate (column->button, &allocation);
8322   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
8323
8324   tree_view->priv->drag_column = column;
8325   gdk_window_show (tree_view->priv->drag_window);
8326
8327   gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
8328   gdk_drawable_get_size (tree_view->priv->header_window, &width, &height);
8329
8330   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8331   while (gtk_events_pending ())
8332     gtk_main_iteration ();
8333
8334   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG);
8335   gdk_pointer_grab (tree_view->priv->drag_window,
8336                     FALSE,
8337                     GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
8338                     NULL, NULL, GDK_CURRENT_TIME);
8339   gdk_keyboard_grab (tree_view->priv->drag_window,
8340                      FALSE,
8341                      GDK_CURRENT_TIME);
8342 }
8343
8344 static void
8345 gtk_tree_view_queue_draw_arrow (GtkTreeView      *tree_view,
8346                                 GtkRBTree        *tree,
8347                                 GtkRBNode        *node,
8348                                 GdkRectangle     *clip_rect)
8349 {
8350   GdkRectangle rect;
8351
8352   if (!GTK_WIDGET_REALIZED (tree_view))
8353     return;
8354
8355   rect.x = 0;
8356   rect.width = MAX (tree_view->priv->expander_size, GTK_WIDGET (tree_view)->allocation.width);
8357
8358   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
8359   rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
8360
8361   if (clip_rect)
8362     {
8363       GdkRectangle new_rect;
8364
8365       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
8366
8367       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
8368     }
8369   else
8370     {
8371       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
8372     }
8373 }
8374
8375 void
8376 _gtk_tree_view_queue_draw_node (GtkTreeView  *tree_view,
8377                                 GtkRBTree    *tree,
8378                                 GtkRBNode    *node,
8379                                 GdkRectangle *clip_rect)
8380 {
8381   GdkRectangle rect;
8382
8383   if (!GTK_WIDGET_REALIZED (tree_view))
8384     return;
8385
8386   rect.x = 0;
8387   rect.width = MAX (tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width);
8388
8389   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
8390   rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
8391
8392   if (clip_rect)
8393     {
8394       GdkRectangle new_rect;
8395
8396       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
8397
8398       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
8399     }
8400   else
8401     {
8402       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
8403     }
8404 }
8405
8406 static void
8407 gtk_tree_view_queue_draw_path (GtkTreeView      *tree_view,
8408                                GtkTreePath      *path,
8409                                GdkRectangle     *clip_rect)
8410 {
8411   GtkRBTree *tree = NULL;
8412   GtkRBNode *node = NULL;
8413
8414   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
8415
8416   if (tree)
8417     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
8418 }
8419
8420 /* x and y are the mouse position
8421  */
8422 static void
8423 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
8424                           GtkRBTree   *tree,
8425                           GtkRBNode   *node,
8426                           gint         x,
8427                           gint         y)
8428 {
8429   GdkRectangle area;
8430   GtkStateType state;
8431   GtkWidget *widget;
8432   gint x_offset = 0;
8433   gint vertical_separator;
8434   gint expander_size;
8435   GtkExpanderStyle expander_style;
8436
8437   gtk_widget_style_get (GTK_WIDGET (tree_view),
8438                         "vertical-separator", &vertical_separator,
8439                         NULL);
8440   expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
8441
8442   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
8443     return;
8444
8445   widget = GTK_WIDGET (tree_view);
8446
8447   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, NULL);
8448
8449   area.x = x_offset;
8450   area.y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
8451   area.width = expander_size + 2;
8452   area.height = MAX (CELL_HEIGHT (node, vertical_separator), (expander_size - vertical_separator));
8453
8454   if (GTK_WIDGET_STATE (tree_view) == GTK_STATE_INSENSITIVE)
8455     {
8456       state = GTK_STATE_INSENSITIVE;
8457     }
8458   else if (node == tree_view->priv->button_pressed_node)
8459     {
8460       if (x >= area.x && x <= (area.x + area.width) &&
8461           y >= area.y && y <= (area.y + area.height))
8462         state = GTK_STATE_ACTIVE;
8463       else
8464         state = GTK_STATE_NORMAL;
8465     }
8466   else
8467     {
8468       if (node == tree_view->priv->prelight_node &&
8469           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
8470         state = GTK_STATE_PRELIGHT;
8471       else
8472         state = GTK_STATE_NORMAL;
8473     }
8474
8475   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
8476     expander_style = GTK_EXPANDER_SEMI_EXPANDED;
8477   else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
8478     expander_style = GTK_EXPANDER_SEMI_COLLAPSED;
8479   else if (node->children != NULL)
8480     expander_style = GTK_EXPANDER_EXPANDED;
8481   else
8482     expander_style = GTK_EXPANDER_COLLAPSED;
8483
8484   gtk_paint_expander (widget->style,
8485                       tree_view->priv->bin_window,
8486                       state,
8487                       &area,
8488                       widget,
8489                       "treeview",
8490                       area.x + area.width / 2,
8491                       area.y + area.height / 2,
8492                       expander_style);
8493 }
8494
8495 static void
8496 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
8497
8498 {
8499   GtkTreePath *cursor_path;
8500
8501   if ((tree_view->priv->tree == NULL) ||
8502       (! GTK_WIDGET_REALIZED (tree_view)))
8503     return;
8504
8505   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
8506
8507   cursor_path = NULL;
8508   if (tree_view->priv->cursor)
8509     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8510
8511   if (cursor_path == NULL)
8512     {
8513       /* Consult the selection before defaulting to the first element */
8514       GtkTreeSelection *selection;
8515       GtkTreeModel     *model;
8516       GList            *selected_rows;
8517
8518       selection = gtk_tree_view_get_selection (tree_view);
8519       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
8520       if (selected_rows)
8521         {
8522           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
8523           g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
8524           g_list_free (selected_rows);
8525         }
8526       else
8527         cursor_path = gtk_tree_path_new_first ();
8528
8529       gtk_tree_row_reference_free (tree_view->priv->cursor);
8530       tree_view->priv->cursor = NULL;
8531
8532       if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE)
8533         gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE);
8534       else
8535         gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
8536     }
8537   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
8538   gtk_tree_path_free (cursor_path);
8539
8540   if (tree_view->priv->focus_column == NULL)
8541     {
8542       GList *list;
8543       for (list = tree_view->priv->columns; list; list = list->next)
8544         {
8545           if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
8546             {
8547               tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
8548               break;
8549             }
8550         }
8551     }
8552 }
8553
8554 static void
8555 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
8556                                    gint         count)
8557 {
8558   GtkRBTree *cursor_tree = NULL;
8559   GtkRBNode *cursor_node = NULL;
8560   GtkRBTree *new_cursor_tree = NULL;
8561   GtkRBNode *new_cursor_node = NULL;
8562   GtkTreePath *cursor_path = NULL;
8563
8564   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
8565     return;
8566
8567   cursor_path = NULL;
8568   if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
8569     /* FIXME: we lost the cursor; should we get the first? */
8570     return;
8571
8572   cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8573   _gtk_tree_view_find_node (tree_view, cursor_path,
8574                             &cursor_tree, &cursor_node);
8575   gtk_tree_path_free (cursor_path);
8576
8577   if (cursor_tree == NULL)
8578     /* FIXME: we lost the cursor; should we get the first? */
8579     return;
8580   if (count == -1)
8581     _gtk_rbtree_prev_full (cursor_tree, cursor_node,
8582                            &new_cursor_tree, &new_cursor_node);
8583   else
8584     _gtk_rbtree_next_full (cursor_tree, cursor_node,
8585                            &new_cursor_tree, &new_cursor_node);
8586
8587   /*
8588    * If the list has only one item and multi-selection is set then select
8589    * the row.
8590    */
8591   if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE &&
8592       new_cursor_node == NULL)
8593     {
8594       if (count == -1)
8595         _gtk_rbtree_next_full (cursor_tree, cursor_node,
8596                                &new_cursor_tree, &new_cursor_node);
8597       else
8598         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
8599                                &new_cursor_tree, &new_cursor_node);
8600
8601       if (new_cursor_node == NULL)
8602         {
8603           new_cursor_node = cursor_node;
8604           new_cursor_tree = cursor_tree;
8605         }
8606       else
8607         {
8608           new_cursor_node = NULL;
8609         }
8610     }
8611
8612   if (new_cursor_node)
8613     {
8614       cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node);
8615       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
8616       gtk_tree_path_free (cursor_path);
8617     }
8618   else
8619     {
8620       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
8621     }
8622
8623   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8624 }
8625
8626 static void
8627 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
8628                                         gint         count)
8629 {
8630   GtkRBTree *cursor_tree = NULL;
8631   GtkRBNode *cursor_node = NULL;
8632   GtkTreePath *cursor_path = NULL;
8633   gint y;
8634   gint window_y;
8635   gint vertical_separator;
8636
8637   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
8638     return;
8639
8640   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
8641     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8642   else
8643     /* This is sorta weird.  Focus in should give us a cursor */
8644     return;
8645
8646   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
8647   _gtk_tree_view_find_node (tree_view, cursor_path,
8648                             &cursor_tree, &cursor_node);
8649
8650   gtk_tree_path_free (cursor_path);
8651
8652   if (cursor_tree == NULL)
8653     /* FIXME: we lost the cursor.  Should we try to get one? */
8654     return;
8655   g_return_if_fail (cursor_node != NULL);
8656
8657   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
8658   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
8659   y += count * (int)tree_view->priv->vadjustment->page_increment;
8660   y = CLAMP (y, (gint)tree_view->priv->vadjustment->lower,  (gint)tree_view->priv->vadjustment->upper - vertical_separator);
8661
8662   if (y >= tree_view->priv->height)
8663     y = tree_view->priv->height - 1;
8664
8665   y -= _gtk_rbtree_find_offset (tree_view->priv->tree, y, &cursor_tree, &cursor_node);
8666   cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
8667   g_return_if_fail (cursor_path != NULL);
8668   gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
8669   gtk_tree_path_free (cursor_path);
8670
8671   y -= window_y;
8672   gtk_tree_view_scroll_to_point (tree_view, -1, y);
8673 }
8674
8675 static void
8676 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
8677                                       gint         count)
8678 {
8679   GtkRBTree *cursor_tree = NULL;
8680   GtkRBNode *cursor_node = NULL;
8681   GtkTreePath *cursor_path = NULL;
8682   GtkTreeViewColumn *column;
8683   GtkTreeIter iter;
8684   GList *list;
8685   gboolean found_column = FALSE;
8686   gboolean rtl;
8687
8688   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8689
8690   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
8691     return;
8692
8693   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
8694     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8695   else
8696     return;
8697
8698   _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node);
8699   if (cursor_tree == NULL)
8700     return;
8701   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
8702     {
8703       gtk_tree_path_free (cursor_path);
8704       return;
8705     }
8706   gtk_tree_path_free (cursor_path);
8707
8708   list = tree_view->priv->columns;
8709   if (tree_view->priv->focus_column)
8710     {
8711       for (list = tree_view->priv->columns; list; list = list->next)
8712         {
8713           if (list->data == tree_view->priv->focus_column)
8714             break;
8715         }
8716     }
8717
8718   while (list)
8719     {
8720       column = list->data;
8721       if (column->visible == FALSE)
8722         goto loop_end;
8723
8724       gtk_tree_view_column_cell_set_cell_data (column,
8725                                                tree_view->priv->model,
8726                                                &iter,
8727                                                GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
8728                                                cursor_node->children?TRUE:FALSE);
8729       if (_gtk_tree_view_column_cell_focus (column, count,
8730                                             list->prev?TRUE:FALSE,
8731                                             list->next?TRUE:FALSE))
8732         {
8733           tree_view->priv->focus_column = column;
8734           found_column = TRUE;
8735           break;
8736         }
8737     loop_end:
8738       if (count == 1)
8739         list = rtl ? list->prev : list->next;
8740       else
8741         list = rtl ? list->next : list->prev;
8742     }
8743
8744   if (found_column)
8745     {
8746       if (!gtk_tree_view_has_special_cell (tree_view))
8747         _gtk_tree_view_queue_draw_node (tree_view,
8748                                         cursor_tree,
8749                                         cursor_node,
8750                                         NULL);
8751       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
8752     }
8753   gtk_tree_view_clamp_column_visible (tree_view, tree_view->priv->focus_column);
8754 }
8755
8756 static void
8757 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
8758                                      gint         count)
8759 {
8760   GtkRBTree *cursor_tree;
8761   GtkRBNode *cursor_node;
8762   GtkTreePath *path;
8763
8764   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
8765     return;
8766
8767   g_return_if_fail (tree_view->priv->tree != NULL);
8768
8769   if (count == -1)
8770     {
8771       cursor_tree = tree_view->priv->tree;
8772       cursor_node = cursor_tree->root;
8773       while (cursor_node && cursor_node->left != cursor_tree->nil)
8774         cursor_node = cursor_node->left;
8775     }
8776   else
8777     {
8778       cursor_tree = tree_view->priv->tree;
8779       cursor_node = cursor_tree->root;
8780       do
8781         {
8782           while (cursor_node && cursor_node->right != cursor_tree->nil)
8783             cursor_node = cursor_node->right;
8784           if (cursor_node->children == NULL)
8785             break;
8786
8787           cursor_tree = cursor_node->children;
8788           cursor_node = cursor_tree->root;
8789         }
8790       while (1);
8791     }
8792
8793   path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
8794   gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
8795   gtk_tree_path_free (path);
8796 }
8797
8798 static gboolean
8799 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
8800 {
8801   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
8802     return FALSE;
8803
8804   if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
8805     return FALSE;
8806
8807   gtk_tree_selection_select_all (tree_view->priv->selection);
8808
8809   return TRUE;
8810 }
8811
8812 static gboolean
8813 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
8814 {
8815   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
8816     return FALSE;
8817
8818   if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
8819     return FALSE;
8820
8821   gtk_tree_selection_unselect_all (tree_view->priv->selection);
8822
8823   return TRUE;
8824 }
8825
8826 static gboolean
8827 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
8828                                       gboolean     start_editing)
8829 {
8830   GtkRBTree *cursor_tree = NULL;
8831   GtkRBNode *cursor_node = NULL;
8832   GtkTreePath *cursor_path = NULL;
8833   GtkTreeSelectMode mode = 0;
8834
8835   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
8836     return FALSE;
8837
8838   if (tree_view->priv->cursor)
8839     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8840
8841   if (cursor_path == NULL)
8842     return FALSE;
8843
8844   _gtk_tree_view_find_node (tree_view, cursor_path,
8845                             &cursor_tree, &cursor_node);
8846
8847   if (cursor_tree == NULL)
8848     {
8849       gtk_tree_path_free (cursor_path);
8850       return FALSE;
8851     }
8852
8853   if (!tree_view->priv->shift_pressed && start_editing &&
8854       tree_view->priv->focus_column)
8855     {
8856       if (gtk_tree_view_start_editing (tree_view, cursor_path))
8857         {
8858           gtk_tree_path_free (cursor_path);
8859           return TRUE;
8860         }
8861     }
8862
8863   if (tree_view->priv->ctrl_pressed)
8864     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
8865   if (tree_view->priv->shift_pressed)
8866     mode |= GTK_TREE_SELECT_MODE_EXTEND;
8867
8868   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
8869                                             cursor_node,
8870                                             cursor_tree,
8871                                             cursor_path,
8872                                             mode,
8873                                             FALSE);
8874
8875   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
8876
8877   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8878   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
8879
8880   if (!tree_view->priv->shift_pressed)
8881     gtk_tree_view_row_activated (tree_view, cursor_path,
8882                                  tree_view->priv->focus_column);
8883
8884   gtk_tree_path_free (cursor_path);
8885
8886   return TRUE;
8887 }
8888
8889 static gboolean
8890 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
8891 {
8892   GtkRBTree *cursor_tree = NULL;
8893   GtkRBNode *cursor_node = NULL;
8894   GtkTreePath *cursor_path = NULL;
8895
8896   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
8897     return FALSE;
8898
8899   cursor_path = NULL;
8900   if (tree_view->priv->cursor)
8901     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8902
8903   if (cursor_path == NULL)
8904     return FALSE;
8905
8906   _gtk_tree_view_find_node (tree_view, cursor_path,
8907                             &cursor_tree, &cursor_node);
8908   if (cursor_tree == NULL)
8909     {
8910       gtk_tree_path_free (cursor_path);
8911       return FALSE;
8912     }
8913
8914   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
8915                                             cursor_node,
8916                                             cursor_tree,
8917                                             cursor_path,
8918                                             GTK_TREE_SELECT_MODE_TOGGLE,
8919                                             FALSE);
8920
8921   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
8922
8923   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8924   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
8925   gtk_tree_path_free (cursor_path);
8926
8927   return TRUE;
8928 }
8929
8930 static gboolean
8931 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
8932                                                gboolean     logical,
8933                                                gboolean     expand,
8934                                                gboolean     open_all)
8935 {
8936   GtkTreePath *cursor_path = NULL;
8937   GtkRBTree *tree;
8938   GtkRBNode *node;
8939
8940   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
8941     return FALSE;
8942
8943   cursor_path = NULL;
8944   if (tree_view->priv->cursor)
8945     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8946
8947   if (cursor_path == NULL)
8948     return FALSE;
8949
8950   if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node))
8951     return FALSE;
8952
8953   /* Don't handle the event if we aren't an expander */
8954   if (!((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT))
8955     return FALSE;
8956
8957   if (!logical
8958       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
8959     expand = !expand;
8960
8961   if (expand)
8962     gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE);
8963   else
8964     gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE);
8965
8966   gtk_tree_path_free (cursor_path);
8967
8968   return TRUE;
8969 }
8970
8971 static gboolean
8972 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
8973 {
8974   GtkRBTree *cursor_tree = NULL;
8975   GtkRBNode *cursor_node = NULL;
8976   GtkTreePath *cursor_path = NULL;
8977   GdkModifierType state;
8978
8979   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
8980     return FALSE;
8981
8982   cursor_path = NULL;
8983   if (tree_view->priv->cursor)
8984     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8985
8986   if (cursor_path == NULL)
8987     return FALSE;
8988
8989   _gtk_tree_view_find_node (tree_view, cursor_path,
8990                             &cursor_tree, &cursor_node);
8991   if (cursor_tree == NULL)
8992     {
8993       gtk_tree_path_free (cursor_path);
8994       return FALSE;
8995     }
8996
8997   if (gtk_get_current_event_state (&state))
8998     {
8999       if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9000         tree_view->priv->ctrl_pressed = TRUE;
9001     }
9002
9003   if (cursor_tree->parent_node)
9004     {
9005       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
9006       cursor_node = cursor_tree->parent_node;
9007       cursor_tree = cursor_tree->parent_tree;
9008
9009       gtk_tree_path_up (cursor_path);
9010
9011       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
9012     }
9013
9014   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
9015
9016   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9017   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
9018   gtk_tree_path_free (cursor_path);
9019
9020   tree_view->priv->ctrl_pressed = FALSE;
9021
9022   return TRUE;
9023 }
9024 static gboolean
9025 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
9026 {
9027   GDK_THREADS_ENTER ();
9028
9029   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view);
9030   tree_view->priv->typeselect_flush_timeout = 0;
9031
9032   GDK_THREADS_LEAVE ();
9033
9034   return TRUE;
9035 }
9036
9037 /* Cut and paste from gtkwindow.c */
9038 static void
9039 send_focus_change (GtkWidget *widget,
9040                    gboolean   in)
9041 {
9042   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
9043
9044   g_object_ref (widget);
9045
9046  if (in)
9047     GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
9048   else
9049     GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
9050
9051   fevent->focus_change.type = GDK_FOCUS_CHANGE;
9052   fevent->focus_change.window = g_object_ref (widget->window);
9053   fevent->focus_change.in = in;
9054
9055   gtk_widget_event (widget, fevent);
9056
9057   g_object_notify (G_OBJECT (widget), "has-focus");
9058
9059   g_object_unref (widget);
9060   gdk_event_free (fevent);
9061 }
9062
9063 static void
9064 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
9065 {
9066   GtkWidget *frame, *vbox, *toplevel;
9067
9068   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
9069
9070    if (tree_view->priv->search_window != NULL)
9071      {
9072        if (GTK_WINDOW (toplevel)->group)
9073          gtk_window_group_add_window (GTK_WINDOW (toplevel)->group,
9074                                       GTK_WINDOW (tree_view->priv->search_window));
9075        else if (GTK_WINDOW (tree_view->priv->search_window)->group)
9076          gtk_window_group_remove_window (GTK_WINDOW (tree_view->priv->search_window)->group,
9077                                          GTK_WINDOW (tree_view->priv->search_window));
9078        return;
9079      }
9080
9081   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
9082
9083   if (GTK_WINDOW (toplevel)->group)
9084     gtk_window_group_add_window (GTK_WINDOW (toplevel)->group,
9085                                  GTK_WINDOW (tree_view->priv->search_window));
9086
9087   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
9088   g_signal_connect (tree_view->priv->search_window, "delete_event",
9089                     G_CALLBACK (gtk_tree_view_search_delete_event),
9090                     tree_view);
9091   g_signal_connect (tree_view->priv->search_window, "key_press_event",
9092                     G_CALLBACK (gtk_tree_view_search_key_press_event),
9093                     tree_view);
9094   g_signal_connect (tree_view->priv->search_window, "button_press_event",
9095                     G_CALLBACK (gtk_tree_view_search_button_press_event),
9096                     tree_view);
9097   g_signal_connect (tree_view->priv->search_window, "scroll_event",
9098                     G_CALLBACK (gtk_tree_view_search_scroll_event),
9099                     tree_view);
9100
9101   frame = gtk_frame_new (NULL);
9102   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
9103   gtk_widget_show (frame);
9104   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
9105
9106   vbox = gtk_vbox_new (FALSE, 0);
9107   gtk_widget_show (vbox);
9108   gtk_container_add (GTK_CONTAINER (frame), vbox);
9109   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
9110
9111   /* add entry */
9112   tree_view->priv->search_entry = gtk_entry_new ();
9113   gtk_widget_show (tree_view->priv->search_entry);
9114   g_signal_connect (tree_view->priv->search_entry, "populate_popup",
9115                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
9116                     tree_view);
9117   g_signal_connect (tree_view->priv->search_entry,
9118                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
9119                     tree_view);
9120   g_signal_connect (GTK_ENTRY (tree_view->priv->search_entry)->im_context,
9121                     "preedit-changed",
9122                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
9123                     tree_view);
9124   gtk_container_add (GTK_CONTAINER (vbox),
9125                      tree_view->priv->search_entry);
9126
9127   gtk_widget_realize (tree_view->priv->search_entry);
9128 }
9129
9130 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
9131  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
9132  */
9133 static gboolean
9134 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
9135                                              gboolean     keybinding)
9136 {
9137   /* We only start interactive search if we have focus or the columns
9138    * have focus.  If one of our children have focus, we don't want to
9139    * start the search.
9140    */
9141   GList *list;
9142   gboolean found_focus = FALSE;
9143   GtkWidgetClass *entry_parent_class;
9144
9145   if (!tree_view->priv->enable_search && !keybinding)
9146     return FALSE;
9147
9148   if (tree_view->priv->search_window != NULL &&
9149       GTK_WIDGET_VISIBLE (tree_view->priv->search_window))
9150     return TRUE;
9151
9152   for (list = tree_view->priv->columns; list; list = list->next)
9153     {
9154       GtkTreeViewColumn *column;
9155
9156       column = list->data;
9157       if (! column->visible)
9158         continue;
9159
9160       if (GTK_WIDGET_HAS_FOCUS (column->button))
9161         {
9162           found_focus = TRUE;
9163           break;
9164         }
9165     }
9166
9167   if (GTK_WIDGET_HAS_FOCUS (tree_view))
9168     found_focus = TRUE;
9169
9170   if (!found_focus)
9171     return FALSE;
9172
9173   if (tree_view->priv->search_column < 0)
9174     return FALSE;
9175
9176   gtk_tree_view_ensure_interactive_directory (tree_view);
9177
9178   if (keybinding)
9179     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
9180
9181   /* done, show it */
9182   tree_view->priv->search_dialog_position_func (tree_view, tree_view->priv->search_window);
9183   gtk_widget_show (tree_view->priv->search_window);
9184   if (tree_view->priv->search_entry_changed_id == 0)
9185     {
9186       tree_view->priv->search_entry_changed_id =
9187         g_signal_connect (tree_view->priv->search_entry, "changed",
9188                           G_CALLBACK (gtk_tree_view_search_init),
9189                           tree_view);
9190     }
9191
9192   tree_view->priv->typeselect_flush_timeout =
9193     g_timeout_add (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
9194                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
9195                    tree_view);
9196
9197   /* Grab focus will select all the text.  We don't want that to happen, so we
9198    * call the parent instance and bypass the selection change.  This is probably
9199    * really non-kosher. */
9200   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
9201   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
9202
9203   /* send focus-in event */
9204   send_focus_change (tree_view->priv->search_entry, TRUE);
9205
9206   /* search first matching iter */
9207   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
9208
9209   return TRUE;
9210 }
9211
9212 static gboolean
9213 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
9214 {
9215   return gtk_tree_view_real_start_interactive_search (tree_view, TRUE);
9216 }
9217 /* this function returns the new width of the column being resized given
9218  * the column and x position of the cursor; the x cursor position is passed
9219  * in as a pointer and automagicly corrected if it's beyond min/max limits
9220  */
9221 static gint
9222 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
9223                                 gint       i,
9224                                 gint      *x)
9225 {
9226   GtkTreeViewColumn *column;
9227   gint width;
9228   gboolean rtl;
9229
9230   /* first translate the x position from widget->window
9231    * to clist->clist_window
9232    */
9233   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9234   column = g_list_nth (tree_view->priv->columns, i)->data;
9235   width = rtl ? (column->button->allocation.x + column->button->allocation.width - *x) : (*x - column->button->allocation.x);
9236
9237   /* Clamp down the value */
9238   if (column->min_width == -1)
9239     width = MAX (column->button->requisition.width,
9240                  width);
9241   else
9242     width = MAX (column->min_width,
9243                  width);
9244   if (column->max_width != -1)
9245     width = MIN (width, column->max_width);
9246
9247   *x = rtl ? (column->button->allocation.x + column->button->allocation.width - width) : (column->button->allocation.x + width);
9248
9249   return width;
9250 }
9251
9252
9253 /* FIXME this adjust_allocation is a big cut-and-paste from
9254  * GtkCList, needs to be some "official" way to do this
9255  * factored out.
9256  */
9257 typedef struct
9258 {
9259   GdkWindow *window;
9260   int dx;
9261   int dy;
9262 } ScrollData;
9263
9264 /* The window to which widget->window is relative */
9265 #define ALLOCATION_WINDOW(widget)               \
9266    (GTK_WIDGET_NO_WINDOW (widget) ?             \
9267     (widget)->window :                          \
9268      gdk_window_get_parent ((widget)->window))
9269
9270 static void
9271 adjust_allocation_recurse (GtkWidget *widget,
9272                            gpointer   data)
9273 {
9274   ScrollData *scroll_data = data;
9275
9276   /* Need to really size allocate instead of just poking
9277    * into widget->allocation if the widget is not realized.
9278    * FIXME someone figure out why this was.
9279    */
9280   if (!GTK_WIDGET_REALIZED (widget))
9281     {
9282       if (GTK_WIDGET_VISIBLE (widget))
9283         {
9284           GdkRectangle tmp_rectangle = widget->allocation;
9285           tmp_rectangle.x += scroll_data->dx;
9286           tmp_rectangle.y += scroll_data->dy;
9287
9288           gtk_widget_size_allocate (widget, &tmp_rectangle);
9289         }
9290     }
9291   else
9292     {
9293       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
9294         {
9295           widget->allocation.x += scroll_data->dx;
9296           widget->allocation.y += scroll_data->dy;
9297
9298           if (GTK_IS_CONTAINER (widget))
9299             gtk_container_forall (GTK_CONTAINER (widget),
9300                                   adjust_allocation_recurse,
9301                                   data);
9302         }
9303     }
9304 }
9305
9306 static void
9307 adjust_allocation (GtkWidget *widget,
9308                    int        dx,
9309                    int        dy)
9310 {
9311   ScrollData scroll_data;
9312
9313   if (GTK_WIDGET_REALIZED (widget))
9314     scroll_data.window = ALLOCATION_WINDOW (widget);
9315   else
9316     scroll_data.window = NULL;
9317
9318   scroll_data.dx = dx;
9319   scroll_data.dy = dy;
9320
9321   adjust_allocation_recurse (widget, &scroll_data);
9322 }
9323
9324 /* Callbacks */
9325 static void
9326 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
9327                                   GtkTreeView   *tree_view)
9328 {
9329   if (GTK_WIDGET_REALIZED (tree_view))
9330     {
9331       gint dy;
9332
9333       gdk_window_move (tree_view->priv->bin_window,
9334                        - tree_view->priv->hadjustment->value,
9335                        TREE_VIEW_HEADER_HEIGHT (tree_view));
9336       gdk_window_move (tree_view->priv->header_window,
9337                        - tree_view->priv->hadjustment->value,
9338                        0);
9339       dy = tree_view->priv->dy - (int) tree_view->priv->vadjustment->value;
9340       if (dy && tree_view->priv->edited_column)
9341         {
9342           if (GTK_IS_WIDGET (tree_view->priv->edited_column->editable_widget))
9343             {
9344               GList *list;
9345               GtkWidget *widget;
9346               GtkTreeViewChild *child = NULL;
9347
9348               widget = GTK_WIDGET (tree_view->priv->edited_column->editable_widget);
9349               adjust_allocation (widget, 0, dy);
9350
9351               for (list = tree_view->priv->children; list; list = list->next)
9352                 {
9353                   child = (GtkTreeViewChild *)list->data;
9354                   if (child->widget == widget)
9355                     {
9356                       child->y += dy;
9357                       break;
9358                     }
9359                 }
9360             }
9361         }
9362       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
9363
9364       /* update our dy and top_row */
9365       tree_view->priv->dy = (int) tree_view->priv->vadjustment->value;
9366       gtk_tree_view_dy_to_top_row (tree_view);
9367     }
9368 }
9369
9370 \f
9371
9372 /* Public methods
9373  */
9374
9375 /**
9376  * gtk_tree_view_new:
9377  *
9378  * Creates a new #GtkTreeView widget.
9379  *
9380  * Return value: A newly created #GtkTreeView widget.
9381  **/
9382 GtkWidget *
9383 gtk_tree_view_new (void)
9384 {
9385   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
9386 }
9387
9388 /**
9389  * gtk_tree_view_new_with_model:
9390  * @model: the model.
9391  *
9392  * Creates a new #GtkTreeView widget with the model initialized to @model.
9393  *
9394  * Return value: A newly created #GtkTreeView widget.
9395  **/
9396 GtkWidget *
9397 gtk_tree_view_new_with_model (GtkTreeModel *model)
9398 {
9399   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
9400 }
9401
9402 /* Public Accessors
9403  */
9404
9405 /**
9406  * gtk_tree_view_get_model:
9407  * @tree_view: a #GtkTreeView
9408  *
9409  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
9410  * model is unset.
9411  *
9412  * Return value: A #GtkTreeModel, or %NULL if none is currently being used.
9413  **/
9414 GtkTreeModel *
9415 gtk_tree_view_get_model (GtkTreeView *tree_view)
9416 {
9417   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
9418
9419   return tree_view->priv->model;
9420 }
9421
9422 /**
9423  * gtk_tree_view_set_model:
9424  * @tree_view: A #GtkTreeNode.
9425  * @model: The model.
9426  *
9427  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
9428  * set, it will remove it before setting the new model.  If @model is %NULL,
9429  * then it will unset the old model.
9430  **/
9431 void
9432 gtk_tree_view_set_model (GtkTreeView  *tree_view,
9433                          GtkTreeModel *model)
9434 {
9435   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9436
9437   if (model != NULL)
9438     g_return_if_fail (GTK_IS_TREE_MODEL (model));
9439
9440   if (model == tree_view->priv->model)
9441     return;
9442
9443   if (tree_view->priv->model)
9444     {
9445       GList *tmplist = tree_view->priv->columns;
9446
9447       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
9448       gtk_tree_view_stop_editing (tree_view, TRUE);
9449
9450       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
9451                                             gtk_tree_view_row_changed,
9452                                             tree_view);
9453       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
9454                                             gtk_tree_view_row_inserted,
9455                                             tree_view);
9456       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
9457                                             gtk_tree_view_row_has_child_toggled,
9458                                             tree_view);
9459       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
9460                                             gtk_tree_view_row_deleted,
9461                                             tree_view);
9462       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
9463                                             gtk_tree_view_rows_reordered,
9464                                             tree_view);
9465
9466       for (; tmplist; tmplist = tmplist->next)
9467         _gtk_tree_view_column_unset_model (tmplist->data,
9468                                            tree_view->priv->model);
9469
9470       if (tree_view->priv->tree)
9471         {
9472           _gtk_rbtree_free (tree_view->priv->tree);
9473           tree_view->priv->tree = NULL;
9474         }
9475
9476       tree_view->priv->prelight_node = NULL;
9477       tree_view->priv->prelight_tree = NULL;
9478       tree_view->priv->button_pressed_node = NULL;
9479       tree_view->priv->button_pressed_tree = NULL;
9480
9481       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
9482       tree_view->priv->drag_dest_row = NULL;
9483       gtk_tree_row_reference_free (tree_view->priv->cursor);
9484       tree_view->priv->cursor = NULL;
9485       gtk_tree_row_reference_free (tree_view->priv->anchor);
9486       tree_view->priv->anchor = NULL;
9487       gtk_tree_row_reference_free (tree_view->priv->top_row);
9488       tree_view->priv->top_row = NULL;
9489       gtk_tree_row_reference_free (tree_view->priv->last_button_press);
9490       tree_view->priv->last_button_press = NULL;
9491       gtk_tree_row_reference_free (tree_view->priv->last_button_press_2);
9492       tree_view->priv->last_button_press_2 = NULL;
9493       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
9494       tree_view->priv->scroll_to_path = NULL;
9495
9496       tree_view->priv->scroll_to_column = NULL;
9497
9498       g_object_unref (tree_view->priv->model);
9499
9500       tree_view->priv->search_column = -1;
9501       tree_view->priv->fixed_height_check = 0;
9502       tree_view->priv->fixed_height = -1;
9503       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
9504     }
9505
9506   tree_view->priv->model = model;
9507
9508
9509   if (tree_view->priv->model)
9510     {
9511       gint i;
9512       GtkTreePath *path;
9513       GtkTreeIter iter;
9514       GtkTreeModelFlags flags;
9515
9516       if (tree_view->priv->search_column == -1)
9517         {
9518           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
9519             {
9520               GType type = gtk_tree_model_get_column_type (model, i);
9521
9522               if (g_value_type_transformable (type, G_TYPE_STRING))
9523                 {
9524                   tree_view->priv->search_column = i;
9525                   break;
9526                 }
9527             }
9528         }
9529
9530       g_object_ref (tree_view->priv->model);
9531       g_signal_connect (tree_view->priv->model,
9532                         "row_changed",
9533                         G_CALLBACK (gtk_tree_view_row_changed),
9534                         tree_view);
9535       g_signal_connect (tree_view->priv->model,
9536                         "row_inserted",
9537                         G_CALLBACK (gtk_tree_view_row_inserted),
9538                         tree_view);
9539       g_signal_connect (tree_view->priv->model,
9540                         "row_has_child_toggled",
9541                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
9542                         tree_view);
9543       g_signal_connect (tree_view->priv->model,
9544                         "row_deleted",
9545                         G_CALLBACK (gtk_tree_view_row_deleted),
9546                         tree_view);
9547       g_signal_connect (tree_view->priv->model,
9548                         "rows_reordered",
9549                         G_CALLBACK (gtk_tree_view_rows_reordered),
9550                         tree_view);
9551
9552       flags = gtk_tree_model_get_flags (tree_view->priv->model);
9553       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
9554         GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
9555       else
9556         GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
9557
9558       path = gtk_tree_path_new_first ();
9559       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
9560         {
9561           tree_view->priv->tree = _gtk_rbtree_new ();
9562           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
9563         }
9564       gtk_tree_path_free (path);
9565
9566       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
9567       install_presize_handler (tree_view);
9568     }
9569
9570   g_object_notify (G_OBJECT (tree_view), "model");
9571
9572   if (GTK_WIDGET_REALIZED (tree_view))
9573     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9574 }
9575
9576 /**
9577  * gtk_tree_view_get_selection:
9578  * @tree_view: A #GtkTreeView.
9579  *
9580  * Gets the #GtkTreeSelection associated with @tree_view.
9581  *
9582  * Return value: A #GtkTreeSelection object.
9583  **/
9584 GtkTreeSelection *
9585 gtk_tree_view_get_selection (GtkTreeView *tree_view)
9586 {
9587   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
9588
9589   return tree_view->priv->selection;
9590 }
9591
9592 /**
9593  * gtk_tree_view_get_hadjustment:
9594  * @tree_view: A #GtkTreeView
9595  *
9596  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
9597  *
9598  * Return value: A #GtkAdjustment object, or %NULL if none is currently being
9599  * used.
9600  **/
9601 GtkAdjustment *
9602 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
9603 {
9604   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
9605
9606   if (tree_view->priv->hadjustment == NULL)
9607     gtk_tree_view_set_hadjustment (tree_view, NULL);
9608
9609   return tree_view->priv->hadjustment;
9610 }
9611
9612 /**
9613  * gtk_tree_view_set_hadjustment:
9614  * @tree_view: A #GtkTreeView
9615  * @adjustment: The #GtkAdjustment to set, or %NULL
9616  *
9617  * Sets the #GtkAdjustment for the current horizontal aspect.
9618  **/
9619 void
9620 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
9621                                GtkAdjustment *adjustment)
9622 {
9623   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9624
9625   gtk_tree_view_set_adjustments (tree_view,
9626                                  adjustment,
9627                                  tree_view->priv->vadjustment);
9628
9629   g_object_notify (G_OBJECT (tree_view), "hadjustment");
9630 }
9631
9632 /**
9633  * gtk_tree_view_get_vadjustment:
9634  * @tree_view: A #GtkTreeView
9635  *
9636  * Gets the #GtkAdjustment currently being used for the vertical aspect.
9637  *
9638  * Return value: A #GtkAdjustment object, or %NULL if none is currently being
9639  * used.
9640  **/
9641 GtkAdjustment *
9642 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
9643 {
9644   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
9645
9646   if (tree_view->priv->vadjustment == NULL)
9647     gtk_tree_view_set_vadjustment (tree_view, NULL);
9648
9649   return tree_view->priv->vadjustment;
9650 }
9651
9652 /**
9653  * gtk_tree_view_set_vadjustment:
9654  * @tree_view: A #GtkTreeView
9655  * @adjustment: The #GtkAdjustment to set, or %NULL
9656  *
9657  * Sets the #GtkAdjustment for the current vertical aspect.
9658  **/
9659 void
9660 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
9661                                GtkAdjustment *adjustment)
9662 {
9663   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9664
9665   gtk_tree_view_set_adjustments (tree_view,
9666                                  tree_view->priv->hadjustment,
9667                                  adjustment);
9668
9669   g_object_notify (G_OBJECT (tree_view), "vadjustment");
9670 }
9671
9672 /* Column and header operations */
9673
9674 /**
9675  * gtk_tree_view_get_headers_visible:
9676  * @tree_view: A #GtkTreeView.
9677  *
9678  * Returns %TRUE if the headers on the @tree_view are visible.
9679  *
9680  * Return value: Whether the headers are visible or not.
9681  **/
9682 gboolean
9683 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
9684 {
9685   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
9686
9687   return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
9688 }
9689
9690 /**
9691  * gtk_tree_view_set_headers_visible:
9692  * @tree_view: A #GtkTreeView.
9693  * @headers_visible: %TRUE if the headers are visible
9694  *
9695  * Sets the visibility state of the headers.
9696  **/
9697 void
9698 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
9699                                    gboolean     headers_visible)
9700 {
9701   gint x, y;
9702   GList *list;
9703   GtkTreeViewColumn *column;
9704
9705   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9706
9707   headers_visible = !! headers_visible;
9708
9709   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE) == headers_visible)
9710     return;
9711
9712   if (headers_visible)
9713     GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
9714   else
9715     GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
9716
9717   if (GTK_WIDGET_REALIZED (tree_view))
9718     {
9719       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
9720       if (headers_visible)
9721         {
9722           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));
9723
9724           if (GTK_WIDGET_MAPPED (tree_view))
9725             gtk_tree_view_map_buttons (tree_view);
9726         }
9727       else
9728         {
9729           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
9730
9731           for (list = tree_view->priv->columns; list; list = list->next)
9732             {
9733               column = list->data;
9734               gtk_widget_unmap (column->button);
9735             }
9736           gdk_window_hide (tree_view->priv->header_window);
9737         }
9738     }
9739
9740   tree_view->priv->vadjustment->page_size = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
9741   tree_view->priv->vadjustment->page_increment = (GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2;
9742   tree_view->priv->vadjustment->lower = 0;
9743   tree_view->priv->vadjustment->upper = tree_view->priv->height;
9744   gtk_adjustment_changed (tree_view->priv->vadjustment);
9745
9746   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9747
9748   g_object_notify (G_OBJECT (tree_view), "headers-visible");
9749 }
9750
9751 /**
9752  * gtk_tree_view_columns_autosize:
9753  * @tree_view: A #GtkTreeView.
9754  *
9755  * Resizes all columns to their optimal width. Only works after the
9756  * treeview has been realized.
9757  **/
9758 void
9759 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
9760 {
9761   gboolean dirty = FALSE;
9762   GList *list;
9763   GtkTreeViewColumn *column;
9764
9765   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9766
9767   for (list = tree_view->priv->columns; list; list = list->next)
9768     {
9769       column = list->data;
9770       if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9771         continue;
9772       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
9773       dirty = TRUE;
9774     }
9775
9776   if (dirty)
9777     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9778 }
9779
9780 /**
9781  * gtk_tree_view_set_headers_clickable:
9782  * @tree_view: A #GtkTreeView.
9783  * @setting: %TRUE if the columns are clickable.
9784  *
9785  * Allow the column title buttons to be clicked.
9786  **/
9787 void
9788 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
9789                                      gboolean   setting)
9790 {
9791   GList *list;
9792
9793   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9794
9795   for (list = tree_view->priv->columns; list; list = list->next)
9796     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
9797
9798   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
9799 }
9800
9801
9802 /**
9803  * gtk_tree_view_set_rules_hint
9804  * @tree_view: a #GtkTreeView
9805  * @setting: %TRUE if the tree requires reading across rows
9806  *
9807  * This function tells GTK+ that the user interface for your
9808  * application requires users to read across tree rows and associate
9809  * cells with one another. By default, GTK+ will then render the tree
9810  * with alternating row colors. Do <emphasis>not</emphasis> use it
9811  * just because you prefer the appearance of the ruled tree; that's a
9812  * question for the theme. Some themes will draw tree rows in
9813  * alternating colors even when rules are turned off, and users who
9814  * prefer that appearance all the time can choose those themes. You
9815  * should call this function only as a <emphasis>semantic</emphasis>
9816  * hint to the theme engine that your tree makes alternating colors
9817  * useful from a functional standpoint (since it has lots of columns,
9818  * generally).
9819  *
9820  **/
9821 void
9822 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
9823                               gboolean      setting)
9824 {
9825   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
9826
9827   setting = setting != FALSE;
9828
9829   if (tree_view->priv->has_rules != setting)
9830     {
9831       tree_view->priv->has_rules = setting;
9832       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
9833     }
9834
9835   g_object_notify (G_OBJECT (tree_view), "rules-hint");
9836 }
9837
9838 /**
9839  * gtk_tree_view_get_rules_hint
9840  * @tree_view: a #GtkTreeView
9841  *
9842  * Gets the setting set by gtk_tree_view_set_rules_hint().
9843  *
9844  * Return value: %TRUE if rules are useful for the user of this tree
9845  **/
9846 gboolean
9847 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
9848 {
9849   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
9850
9851   return tree_view->priv->has_rules;
9852 }
9853
9854 /* Public Column functions
9855  */
9856
9857 /**
9858  * gtk_tree_view_append_column:
9859  * @tree_view: A #GtkTreeView.
9860  * @column: The #GtkTreeViewColumn to add.
9861  *
9862  * Appends @column to the list of columns. If @tree_view has "fixed_height"
9863  * mode enabled, then @column must have its "sizing" property set to be
9864  * GTK_TREE_VIEW_COLUMN_FIXED.
9865  *
9866  * Return value: The number of columns in @tree_view after appending.
9867  **/
9868 gint
9869 gtk_tree_view_append_column (GtkTreeView       *tree_view,
9870                              GtkTreeViewColumn *column)
9871 {
9872   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
9873   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
9874   g_return_val_if_fail (column->tree_view == NULL, -1);
9875
9876   return gtk_tree_view_insert_column (tree_view, column, -1);
9877 }
9878
9879
9880 /**
9881  * gtk_tree_view_remove_column:
9882  * @tree_view: A #GtkTreeView.
9883  * @column: The #GtkTreeViewColumn to remove.
9884  *
9885  * Removes @column from @tree_view.
9886  *
9887  * Return value: The number of columns in @tree_view after removing.
9888  **/
9889 gint
9890 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
9891                              GtkTreeViewColumn *column)
9892 {
9893   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
9894   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
9895   g_return_val_if_fail (column->tree_view == GTK_WIDGET (tree_view), -1);
9896
9897   if (tree_view->priv->focus_column == column)
9898     tree_view->priv->focus_column = NULL;
9899
9900   if (tree_view->priv->edited_column == column)
9901     {
9902       gtk_tree_view_stop_editing (tree_view, TRUE);
9903
9904       /* no need to, but just to be sure ... */
9905       tree_view->priv->edited_column = NULL;
9906     }
9907
9908   g_signal_handlers_disconnect_by_func (column,
9909                                         G_CALLBACK (column_sizing_notify),
9910                                         tree_view);
9911
9912   _gtk_tree_view_column_unset_tree_view (column);
9913
9914   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
9915   tree_view->priv->n_columns--;
9916
9917   if (GTK_WIDGET_REALIZED (tree_view))
9918     {
9919       GList *list;
9920
9921       _gtk_tree_view_column_unrealize_button (column);
9922       for (list = tree_view->priv->columns; list; list = list->next)
9923         {
9924           GtkTreeViewColumn *tmp_column;
9925
9926           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
9927           if (tmp_column->visible)
9928             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
9929         }
9930
9931       if (tree_view->priv->n_columns == 0 &&
9932           gtk_tree_view_get_headers_visible (tree_view))
9933         gdk_window_hide (tree_view->priv->header_window);
9934
9935       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9936     }
9937
9938   g_object_unref (column);
9939   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
9940
9941   return tree_view->priv->n_columns;
9942 }
9943
9944 /**
9945  * gtk_tree_view_insert_column:
9946  * @tree_view: A #GtkTreeView.
9947  * @column: The #GtkTreeViewColumn to be inserted.
9948  * @position: The position to insert @column in.
9949  *
9950  * This inserts the @column into the @tree_view at @position.  If @position is
9951  * -1, then the column is inserted at the end. If @tree_view has
9952  * "fixed_height" mode enabled, then @column must have its "sizing" property
9953  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
9954  *
9955  * Return value: The number of columns in @tree_view after insertion.
9956  **/
9957 gint
9958 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
9959                              GtkTreeViewColumn *column,
9960                              gint               position)
9961 {
9962   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
9963   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
9964   g_return_val_if_fail (column->tree_view == NULL, -1);
9965
9966   if (tree_view->priv->fixed_height_mode)
9967     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
9968                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
9969
9970   g_object_ref (column);
9971   gtk_object_sink (GTK_OBJECT (column));
9972
9973   if (tree_view->priv->n_columns == 0 &&
9974       GTK_WIDGET_REALIZED (tree_view) &&
9975       gtk_tree_view_get_headers_visible (tree_view))
9976     {
9977       gdk_window_show (tree_view->priv->header_window);
9978     }
9979
9980   g_signal_connect (column, "notify::sizing",
9981                     G_CALLBACK (column_sizing_notify), tree_view);
9982
9983   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
9984                                             column, position);
9985   tree_view->priv->n_columns++;
9986
9987   _gtk_tree_view_column_set_tree_view (column, tree_view);
9988
9989   if (GTK_WIDGET_REALIZED (tree_view))
9990     {
9991       GList *list;
9992
9993       _gtk_tree_view_column_realize_button (column);
9994
9995       for (list = tree_view->priv->columns; list; list = list->next)
9996         {
9997           column = GTK_TREE_VIEW_COLUMN (list->data);
9998           if (column->visible)
9999             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
10000         }
10001       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
10002     }
10003
10004   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
10005
10006   return tree_view->priv->n_columns;
10007 }
10008
10009 /**
10010  * gtk_tree_view_insert_column_with_attributes:
10011  * @tree_view: A #GtkTreeView
10012  * @position: The position to insert the new column in.
10013  * @title: The title to set the header to.
10014  * @cell: The #GtkCellRenderer.
10015  * @Varargs: A %NULL-terminated list of attributes.
10016  *
10017  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
10018  * @position.  If @position is -1, then the newly created column is inserted at
10019  * the end.  The column is initialized with the attributes given. If @tree_view
10020  * has "fixed_height" mode enabled, then @column must have its sizing
10021  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
10022  *
10023  * Return value: The number of columns in @tree_view after insertion.
10024  **/
10025 gint
10026 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
10027                                              gint             position,
10028                                              const gchar     *title,
10029                                              GtkCellRenderer *cell,
10030                                              ...)
10031 {
10032   GtkTreeViewColumn *column;
10033   gchar *attribute;
10034   va_list args;
10035   gint column_id;
10036
10037   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
10038
10039   column = gtk_tree_view_column_new ();
10040
10041   gtk_tree_view_column_set_title (column, title);
10042   gtk_tree_view_column_pack_start (column, cell, TRUE);
10043
10044   va_start (args, cell);
10045
10046   attribute = va_arg (args, gchar *);
10047
10048   while (attribute != NULL)
10049     {
10050       column_id = va_arg (args, gint);
10051       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
10052       attribute = va_arg (args, gchar *);
10053     }
10054
10055   va_end (args);
10056
10057   gtk_tree_view_insert_column (tree_view, column, position);
10058
10059   return tree_view->priv->n_columns;
10060 }
10061
10062 /**
10063  * gtk_tree_view_insert_column_with_data_func:
10064  * @tree_view: a #GtkTreeView
10065  * @position: Position to insert, -1 for append
10066  * @title: column title
10067  * @cell: cell renderer for column
10068  * @func: function to set attributes of cell renderer
10069  * @data: data for @func
10070  * @dnotify: destroy notifier for @data
10071  *
10072  * Convenience function that inserts a new column into the #GtkTreeView
10073  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
10074  * attributes (normally using data from the model). See also
10075  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
10076  * If @tree_view has "fixed_height" mode enabled, then @column must have its
10077  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
10078  *
10079  * Return value: number of columns in the tree view post-insert
10080  **/
10081 gint
10082 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
10083                                              gint                       position,
10084                                              const gchar               *title,
10085                                              GtkCellRenderer           *cell,
10086                                              GtkTreeCellDataFunc        func,
10087                                              gpointer                   data,
10088                                              GDestroyNotify             dnotify)
10089 {
10090   GtkTreeViewColumn *column;
10091
10092   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
10093
10094   column = gtk_tree_view_column_new ();
10095
10096   gtk_tree_view_column_set_title (column, title);
10097   gtk_tree_view_column_pack_start (column, cell, TRUE);
10098   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
10099
10100   gtk_tree_view_insert_column (tree_view, column, position);
10101
10102   return tree_view->priv->n_columns;
10103 }
10104
10105 /**
10106  * gtk_tree_view_get_column:
10107  * @tree_view: A #GtkTreeView.
10108  * @n: The position of the column, counting from 0.
10109  *
10110  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
10111  *
10112  * Return value: The #GtkTreeViewColumn, or %NULL if the position is outside the
10113  * range of columns.
10114  **/
10115 GtkTreeViewColumn *
10116 gtk_tree_view_get_column (GtkTreeView *tree_view,
10117                           gint         n)
10118 {
10119   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10120
10121   if (n < 0 || n >= tree_view->priv->n_columns)
10122     return NULL;
10123
10124   if (tree_view->priv->columns == NULL)
10125     return NULL;
10126
10127   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
10128 }
10129
10130 /**
10131  * gtk_tree_view_get_columns:
10132  * @tree_view: A #GtkTreeView
10133  *
10134  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
10135  * The returned list must be freed with g_list_free ().
10136  *
10137  * Return value: A list of #GtkTreeViewColumn s
10138  **/
10139 GList *
10140 gtk_tree_view_get_columns (GtkTreeView *tree_view)
10141 {
10142   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10143
10144   return g_list_copy (tree_view->priv->columns);
10145 }
10146
10147 /**
10148  * gtk_tree_view_move_column_after:
10149  * @tree_view: A #GtkTreeView
10150  * @column: The #GtkTreeViewColumn to be moved.
10151  * @base_column: The #GtkTreeViewColumn to be moved relative to, or %NULL.
10152  *
10153  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
10154  * @column is placed in the first position.
10155  **/
10156 void
10157 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
10158                                  GtkTreeViewColumn *column,
10159                                  GtkTreeViewColumn *base_column)
10160 {
10161   GList *column_list_el, *base_el = NULL;
10162
10163   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10164
10165   column_list_el = g_list_find (tree_view->priv->columns, column);
10166   g_return_if_fail (column_list_el != NULL);
10167
10168   if (base_column)
10169     {
10170       base_el = g_list_find (tree_view->priv->columns, base_column);
10171       g_return_if_fail (base_el != NULL);
10172     }
10173
10174   if (column_list_el->prev == base_el)
10175     return;
10176
10177   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
10178   if (base_el == NULL)
10179     {
10180       column_list_el->prev = NULL;
10181       column_list_el->next = tree_view->priv->columns;
10182       if (column_list_el->next)
10183         column_list_el->next->prev = column_list_el;
10184       tree_view->priv->columns = column_list_el;
10185     }
10186   else
10187     {
10188       column_list_el->prev = base_el;
10189       column_list_el->next = base_el->next;
10190       if (column_list_el->next)
10191         column_list_el->next->prev = column_list_el;
10192       base_el->next = column_list_el;
10193     }
10194
10195   if (GTK_WIDGET_REALIZED (tree_view))
10196     {
10197       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
10198       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view));
10199     }
10200
10201   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
10202 }
10203
10204 /**
10205  * gtk_tree_view_set_expander_column:
10206  * @tree_view: A #GtkTreeView
10207  * @column: %NULL, or the column to draw the expander arrow at.
10208  *
10209  * Sets the column to draw the expander arrow at. It must be in @tree_view.
10210  * If @column is %NULL, then the expander arrow is always at the first
10211  * visible column.
10212  *
10213  * If you do not want expander arrow to appear in your tree, set the
10214  * expander column to a hidden column.
10215  **/
10216 void
10217 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
10218                                    GtkTreeViewColumn *column)
10219 {
10220   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10221   if (column != NULL)
10222     g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
10223
10224   if (tree_view->priv->expander_column != column)
10225     {
10226       GList *list;
10227
10228       if (column)
10229         {
10230           /* Confirm that column is in tree_view */
10231           for (list = tree_view->priv->columns; list; list = list->next)
10232             if (list->data == column)
10233               break;
10234           g_return_if_fail (list != NULL);
10235         }
10236
10237       tree_view->priv->expander_column = column;
10238       g_object_notify (G_OBJECT (tree_view), "expander-column");
10239     }
10240 }
10241
10242 /**
10243  * gtk_tree_view_get_expander_column:
10244  * @tree_view: A #GtkTreeView
10245  *
10246  * Returns the column that is the current expander column.  This
10247  * column has the expander arrow drawn next to it.
10248  *
10249  * Return value: The expander column.
10250  **/
10251 GtkTreeViewColumn *
10252 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
10253 {
10254   GList *list;
10255
10256   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10257
10258   for (list = tree_view->priv->columns; list; list = list->next)
10259     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
10260       return (GtkTreeViewColumn *) list->data;
10261   return NULL;
10262 }
10263
10264
10265 /**
10266  * gtk_tree_view_set_column_drag_function:
10267  * @tree_view: A #GtkTreeView.
10268  * @func: A function to determine which columns are reorderable, or %NULL.
10269  * @user_data: User data to be passed to @func, or %NULL
10270  * @destroy: Destroy notifier for @user_data, or %NULL
10271  *
10272  * Sets a user function for determining where a column may be dropped when
10273  * dragged.  This function is called on every column pair in turn at the
10274  * beginning of a column drag to determine where a drop can take place.  The
10275  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
10276  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
10277  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
10278  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
10279  * @tree_view reverts to the default behavior of allowing all columns to be
10280  * dropped everywhere.
10281  **/
10282 void
10283 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
10284                                         GtkTreeViewColumnDropFunc  func,
10285                                         gpointer                   user_data,
10286                                         GtkDestroyNotify           destroy)
10287 {
10288   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10289
10290   if (tree_view->priv->column_drop_func_data_destroy)
10291     (* tree_view->priv->column_drop_func_data_destroy) (tree_view->priv->column_drop_func_data);
10292
10293   tree_view->priv->column_drop_func = func;
10294   tree_view->priv->column_drop_func_data = user_data;
10295   tree_view->priv->column_drop_func_data_destroy = destroy;
10296 }
10297
10298 /**
10299  * gtk_tree_view_scroll_to_point:
10300  * @tree_view: a #GtkTreeView
10301  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
10302  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
10303  *
10304  * Scrolls the tree view such that the top-left corner of the visible
10305  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
10306  * in tree window coordinates.  The @tree_view must be realized before
10307  * this function is called.  If it isn't, you probably want to be
10308  * using gtk_tree_view_scroll_to_cell().
10309  *
10310  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
10311  **/
10312 void
10313 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
10314                                gint         tree_x,
10315                                gint         tree_y)
10316 {
10317   GtkAdjustment *hadj;
10318   GtkAdjustment *vadj;
10319
10320   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10321   g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
10322
10323   hadj = tree_view->priv->hadjustment;
10324   vadj = tree_view->priv->vadjustment;
10325
10326   if (tree_x != -1)
10327     gtk_adjustment_set_value (hadj, CLAMP (tree_x, hadj->lower, hadj->upper - hadj->page_size));
10328   if (tree_y != -1)
10329     gtk_adjustment_set_value (vadj, CLAMP (tree_y, vadj->lower, vadj->upper - vadj->page_size));
10330 }
10331
10332 /**
10333  * gtk_tree_view_scroll_to_cell:
10334  * @tree_view: A #GtkTreeView.
10335  * @path: The path of the row to move to, or %NULL.
10336  * @column: The #GtkTreeViewColumn to move horizontally to, or %NULL.
10337  * @use_align: whether to use alignment arguments, or %FALSE.
10338  * @row_align: The vertical alignment of the row specified by @path.
10339  * @col_align: The horizontal alignment of the column specified by @column.
10340  *
10341  * Moves the alignments of @tree_view to the position specified by @column and
10342  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
10343  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
10344  * or @path need to be non-%NULL.  @row_align determines where the row is
10345  * placed, and @col_align determines where @column is placed.  Both are expected
10346  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
10347  * right/bottom alignment, 0.5 means center.
10348  *
10349  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
10350  * tree does the minimum amount of work to scroll the cell onto the screen.
10351  * This means that the cell will be scrolled to the edge closest to its current
10352  * position.  If the cell is currently visible on the screen, nothing is done.
10353  *
10354  * This function only works if the model is set, and @path is a valid row on the
10355  * model.  If the model changes before the @tree_view is realized, the centered
10356  * path will be modified to reflect this change.
10357  **/
10358 void
10359 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
10360                               GtkTreePath       *path,
10361                               GtkTreeViewColumn *column,
10362                               gboolean           use_align,
10363                               gfloat             row_align,
10364                               gfloat             col_align)
10365 {
10366   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10367   g_return_if_fail (tree_view->priv->model != NULL);
10368   g_return_if_fail (tree_view->priv->tree != NULL);
10369   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
10370   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
10371   g_return_if_fail (path != NULL || column != NULL);
10372
10373 #if 0
10374   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
10375            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
10376 #endif
10377   row_align = CLAMP (row_align, 0.0, 1.0);
10378   col_align = CLAMP (col_align, 0.0, 1.0);
10379
10380
10381   /* Note: Despite the benefits that come from having one code path for the
10382    * scrolling code, we short-circuit validate_visible_area's immplementation as
10383    * it is much slower than just going to the point.
10384    */
10385   if (! GTK_WIDGET_VISIBLE (tree_view) ||
10386       GTK_WIDGET_ALLOC_NEEDED (tree_view) ||
10387       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
10388     {
10389       if (tree_view->priv->scroll_to_path)
10390         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
10391
10392       tree_view->priv->scroll_to_path = NULL;
10393       tree_view->priv->scroll_to_column = NULL;
10394
10395       if (path)
10396         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
10397       if (column)
10398         tree_view->priv->scroll_to_column = column;
10399       tree_view->priv->scroll_to_use_align = use_align;
10400       tree_view->priv->scroll_to_row_align = row_align;
10401       tree_view->priv->scroll_to_col_align = col_align;
10402
10403       install_presize_handler (tree_view);
10404     }
10405   else
10406     {
10407       GdkRectangle cell_rect;
10408       GdkRectangle vis_rect;
10409       gint dest_x, dest_y;
10410
10411       gtk_tree_view_get_cell_area (tree_view, path, column, &cell_rect);
10412       gtk_tree_view_tree_window_to_tree_coords (tree_view, cell_rect.x, cell_rect.y, &(cell_rect.x), &(cell_rect.y));
10413       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
10414
10415       dest_x = vis_rect.x;
10416       dest_y = vis_rect.y;
10417
10418       if (column)
10419         {
10420           if (use_align)
10421             {
10422               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
10423             }
10424           else
10425             {
10426               if (cell_rect.x < vis_rect.x)
10427                 dest_x = cell_rect.x;
10428               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
10429                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
10430             }
10431         }
10432
10433       if (path)
10434         {
10435           if (use_align)
10436             {
10437               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
10438               dest_y = MAX (dest_y, 0);
10439             }
10440           else
10441             {
10442               if (cell_rect.y < vis_rect.y)
10443                 dest_y = cell_rect.y;
10444               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
10445                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
10446             }
10447         }
10448
10449       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
10450     }
10451 }
10452
10453 /**
10454  * gtk_tree_view_row_activated:
10455  * @tree_view: A #GtkTreeView
10456  * @path: The #GtkTreePath to be activated.
10457  * @column: The #GtkTreeViewColumn to be activated.
10458  *
10459  * Activates the cell determined by @path and @column.
10460  **/
10461 void
10462 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
10463                              GtkTreePath       *path,
10464                              GtkTreeViewColumn *column)
10465 {
10466   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10467
10468   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
10469 }
10470
10471
10472 static void
10473 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
10474                                           GtkRBNode *node,
10475                                           gpointer   data)
10476 {
10477   GtkTreeView *tree_view = data;
10478
10479   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
10480       node->children)
10481     {
10482       GtkTreePath *path;
10483       GtkTreeIter iter;
10484
10485       path = _gtk_tree_view_find_path (tree_view, tree, node);
10486       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
10487
10488       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
10489
10490       gtk_tree_path_free (path);
10491     }
10492
10493   if (node->children)
10494     _gtk_rbtree_traverse (node->children,
10495                           node->children->root,
10496                           G_PRE_ORDER,
10497                           gtk_tree_view_expand_all_emission_helper,
10498                           tree_view);
10499 }
10500 /**
10501  * gtk_tree_view_expand_all:
10502  * @tree_view: A #GtkTreeView.
10503  *
10504  * Recursively expands all nodes in the @tree_view.
10505  **/
10506 void
10507 gtk_tree_view_expand_all (GtkTreeView *tree_view)
10508 {
10509   GtkTreePath *path;
10510   GtkRBTree *tree;
10511   GtkRBNode *node;
10512
10513   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10514
10515   if (tree_view->priv->tree == NULL)
10516     return;
10517
10518   path = gtk_tree_path_new_first ();
10519   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
10520
10521   while (node)
10522     {
10523       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
10524       node = _gtk_rbtree_next (tree, node);
10525       gtk_tree_path_next (path);
10526   }
10527
10528   gtk_tree_path_free (path);
10529 }
10530
10531 /* Timeout to animate the expander during expands and collapses */
10532 static gboolean
10533 expand_collapse_timeout (gpointer data)
10534 {
10535   gboolean retval;
10536
10537   GDK_THREADS_ENTER ();
10538
10539   retval = do_expand_collapse (data);
10540
10541   GDK_THREADS_LEAVE ();
10542
10543   return retval;
10544 }
10545
10546 static gboolean
10547 do_expand_collapse (GtkTreeView *tree_view)
10548 {
10549   GtkRBNode *node;
10550   GtkRBTree *tree;
10551   gboolean expanding;
10552   gboolean redraw;
10553
10554   redraw = FALSE;
10555   expanding = TRUE;
10556
10557   node = tree_view->priv->expanded_collapsed_node;
10558   tree = tree_view->priv->expanded_collapsed_tree;
10559
10560   if (node->children == NULL)
10561     expanding = FALSE;
10562
10563   if (expanding)
10564     {
10565       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
10566         {
10567           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
10568           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
10569
10570           redraw = TRUE;
10571
10572         }
10573       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
10574         {
10575           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
10576
10577           redraw = TRUE;
10578         }
10579     }
10580   else
10581     {
10582       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
10583         {
10584           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
10585           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
10586
10587           redraw = TRUE;
10588         }
10589       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
10590         {
10591           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
10592
10593           redraw = TRUE;
10594
10595         }
10596     }
10597
10598   if (redraw)
10599     {
10600       gtk_tree_view_queue_draw_arrow (tree_view, tree, node, NULL);
10601
10602       return TRUE;
10603     }
10604
10605   return FALSE;
10606 }
10607
10608 /**
10609  * gtk_tree_view_collapse_all:
10610  * @tree_view: A #GtkTreeView.
10611  *
10612  * Recursively collapses all visible, expanded nodes in @tree_view.
10613  **/
10614 void
10615 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
10616 {
10617   GtkRBTree *tree;
10618   GtkRBNode *node;
10619   GtkTreePath *path;
10620   gint *indices;
10621
10622   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10623
10624   if (tree_view->priv->tree == NULL)
10625     return;
10626
10627   path = gtk_tree_path_new ();
10628   gtk_tree_path_down (path);
10629   indices = gtk_tree_path_get_indices (path);
10630
10631   tree = tree_view->priv->tree;
10632   node = tree->root;
10633   while (node && node->left != tree->nil)
10634     node = node->left;
10635
10636   while (node)
10637     {
10638       if (node->children)
10639         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
10640       indices[0]++;
10641       node = _gtk_rbtree_next (tree, node);
10642     }
10643
10644   gtk_tree_path_free (path);
10645 }
10646
10647 /**
10648  * gtk_tree_view_expand_to_path:
10649  * @tree_view: A #GtkTreeView.
10650  * @path: path to a row.
10651  *
10652  * Expands the row at @path. This will also expand all parent rows of
10653  * @path as necessary.
10654  *
10655  * Since: 2.2
10656  **/
10657 void
10658 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
10659                               GtkTreePath *path)
10660 {
10661   gint i, depth;
10662   gint *indices;
10663   GtkTreePath *tmp;
10664
10665   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10666   g_return_if_fail (path != NULL);
10667
10668   depth = gtk_tree_path_get_depth (path);
10669   indices = gtk_tree_path_get_indices (path);
10670
10671   tmp = gtk_tree_path_new ();
10672   g_return_if_fail (tmp != NULL);
10673
10674   for (i = 0; i < depth; i++)
10675     {
10676       gtk_tree_path_append_index (tmp, indices[i]);
10677       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
10678     }
10679
10680   gtk_tree_path_free (tmp);
10681 }
10682
10683 /* FIXME the bool return values for expand_row and collapse_row are
10684  * not analagous; they should be TRUE if the row had children and
10685  * was not already in the requested state.
10686  */
10687
10688
10689 static gboolean
10690 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
10691                                GtkTreePath *path,
10692                                GtkRBTree   *tree,
10693                                GtkRBNode   *node,
10694                                gboolean     open_all,
10695                                gboolean     animate)
10696 {
10697   GtkTreeIter iter;
10698   GtkTreeIter temp;
10699   gboolean expand;
10700
10701   remove_auto_expand_timeout (tree_view);
10702
10703   if (node->children && !open_all)
10704     return FALSE;
10705
10706   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
10707     return FALSE;
10708
10709   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
10710   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
10711     return FALSE;
10712
10713
10714    if (node->children && open_all)
10715     {
10716       gboolean retval = FALSE;
10717       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
10718
10719       gtk_tree_path_append_index (tmp_path, 0);
10720       tree = node->children;
10721       node = tree->root;
10722       while (node->left != tree->nil)
10723         node = node->left;
10724       /* try to expand the children */
10725       do
10726         {
10727          gboolean t;
10728          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
10729                                             TRUE, animate);
10730          if (t)
10731            retval = TRUE;
10732
10733          gtk_tree_path_next (tmp_path);
10734          node = _gtk_rbtree_next (tree, node);
10735        }
10736       while (node != NULL);
10737
10738       gtk_tree_path_free (tmp_path);
10739
10740       return retval;
10741     }
10742
10743   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
10744
10745   if (expand)
10746     return FALSE;
10747
10748   node->children = _gtk_rbtree_new ();
10749   node->children->parent_tree = tree;
10750   node->children->parent_node = node;
10751
10752   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
10753
10754   gtk_tree_view_build_tree (tree_view,
10755                             node->children,
10756                             &temp,
10757                             gtk_tree_path_get_depth (path) + 1,
10758                             open_all);
10759
10760   if (tree_view->priv->expand_collapse_timeout)
10761     {
10762       g_source_remove (tree_view->priv->expand_collapse_timeout);
10763       tree_view->priv->expand_collapse_timeout = 0;
10764     }
10765
10766   if (tree_view->priv->expanded_collapsed_node != NULL)
10767     {
10768       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_EXPANDED);
10769       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_COLLAPSED);
10770
10771       tree_view->priv->expanded_collapsed_node = NULL;
10772     }
10773
10774   if (animate)
10775     {
10776       tree_view->priv->expand_collapse_timeout = g_timeout_add (50, expand_collapse_timeout, tree_view);
10777       tree_view->priv->expanded_collapsed_node = node;
10778       tree_view->priv->expanded_collapsed_tree = tree;
10779
10780       GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
10781     }
10782
10783   install_presize_handler (tree_view);
10784
10785   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
10786   if (open_all)
10787     {
10788       _gtk_rbtree_traverse (node->children,
10789                             node->children->root,
10790                             G_PRE_ORDER,
10791                             gtk_tree_view_expand_all_emission_helper,
10792                             tree_view);
10793     }
10794   return TRUE;
10795 }
10796
10797
10798 /**
10799  * gtk_tree_view_expand_row:
10800  * @tree_view: a #GtkTreeView
10801  * @path: path to a row
10802  * @open_all: whether to recursively expand, or just expand immediate children
10803  *
10804  * Opens the row so its children are visible.
10805  *
10806  * Return value: %TRUE if the row existed and had children
10807  **/
10808 gboolean
10809 gtk_tree_view_expand_row (GtkTreeView *tree_view,
10810                           GtkTreePath *path,
10811                           gboolean     open_all)
10812 {
10813   GtkRBTree *tree;
10814   GtkRBNode *node;
10815
10816   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
10817   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
10818   g_return_val_if_fail (path != NULL, FALSE);
10819
10820   if (_gtk_tree_view_find_node (tree_view,
10821                                 path,
10822                                 &tree,
10823                                 &node))
10824     return FALSE;
10825
10826   if (tree != NULL)
10827     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
10828   else
10829     return FALSE;
10830 }
10831
10832 static gboolean
10833 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
10834                                  GtkTreePath *path,
10835                                  GtkRBTree   *tree,
10836                                  GtkRBNode   *node,
10837                                  gboolean     animate)
10838 {
10839   GtkTreeIter iter;
10840   GtkTreeIter children;
10841   gboolean collapse;
10842   gint x, y;
10843   GList *list;
10844   GdkDisplay *display;
10845   GdkWindow *child, *parent;
10846
10847   remove_auto_expand_timeout (tree_view);
10848
10849   if (node->children == NULL)
10850     return FALSE;
10851
10852   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
10853
10854   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
10855
10856   if (collapse)
10857     return FALSE;
10858
10859   /* if the prelighted node is a child of us, we want to unprelight it.  We have
10860    * a chance to prelight the correct node below */
10861
10862   if (tree_view->priv->prelight_tree)
10863     {
10864       GtkRBTree *parent_tree;
10865       GtkRBNode *parent_node;
10866
10867       parent_tree = tree_view->priv->prelight_tree->parent_tree;
10868       parent_node = tree_view->priv->prelight_tree->parent_node;
10869       while (parent_tree)
10870         {
10871           if (parent_tree == tree && parent_node == node)
10872             {
10873               ensure_unprelighted (tree_view);
10874               break;
10875             }
10876           parent_node = parent_tree->parent_node;
10877           parent_tree = parent_tree->parent_tree;
10878         }
10879     }
10880
10881   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
10882
10883   for (list = tree_view->priv->columns; list; list = list->next)
10884     {
10885       GtkTreeViewColumn *column = list->data;
10886
10887       if (column->visible == FALSE)
10888         continue;
10889       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
10890         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
10891     }
10892
10893   if (tree_view->priv->destroy_count_func)
10894     {
10895       GtkTreePath *child_path;
10896       gint child_count = 0;
10897       child_path = gtk_tree_path_copy (path);
10898       gtk_tree_path_down (child_path);
10899       if (node->children)
10900         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
10901       (* tree_view->priv->destroy_count_func) (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
10902       gtk_tree_path_free (child_path);
10903     }
10904
10905   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
10906     {
10907       GtkTreePath *cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10908
10909       if (gtk_tree_path_is_ancestor (path, cursor_path))
10910         {
10911           gtk_tree_row_reference_free (tree_view->priv->cursor);
10912           tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
10913                                                                       tree_view->priv->model,
10914                                                                       path);
10915         }
10916       gtk_tree_path_free (cursor_path);
10917     }
10918
10919   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
10920     {
10921       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
10922       if (gtk_tree_path_is_ancestor (path, anchor_path))
10923         {
10924           gtk_tree_row_reference_free (tree_view->priv->anchor);
10925           tree_view->priv->anchor = NULL;
10926         }
10927       gtk_tree_path_free (anchor_path);
10928     }
10929
10930   if (gtk_tree_row_reference_valid (tree_view->priv->last_button_press))
10931     {
10932       GtkTreePath *lsc = gtk_tree_row_reference_get_path (tree_view->priv->last_button_press);
10933       if (gtk_tree_path_is_ancestor (path, lsc))
10934         {
10935           gtk_tree_row_reference_free (tree_view->priv->last_button_press);
10936           tree_view->priv->last_button_press = NULL;
10937         }
10938       gtk_tree_path_free (lsc);
10939     }
10940
10941   if (gtk_tree_row_reference_valid (tree_view->priv->last_button_press_2))
10942     {
10943       GtkTreePath *lsc = gtk_tree_row_reference_get_path (tree_view->priv->last_button_press_2);
10944       if (gtk_tree_path_is_ancestor (path, lsc))
10945         {
10946           gtk_tree_row_reference_free (tree_view->priv->last_button_press_2);
10947           tree_view->priv->last_button_press_2 = NULL;
10948         }
10949       gtk_tree_path_free (lsc);
10950     }
10951
10952   if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children))
10953     {
10954       _gtk_rbtree_remove (node->children);
10955       g_signal_emit_by_name (tree_view->priv->selection, "changed");
10956     }
10957   else
10958     _gtk_rbtree_remove (node->children);
10959
10960   if (tree_view->priv->expand_collapse_timeout)
10961     {
10962       g_source_remove (tree_view->priv->expand_collapse_timeout);
10963       tree_view->priv->expand_collapse_timeout = 0;
10964     }
10965
10966   if (tree_view->priv->expanded_collapsed_node != NULL)
10967     {
10968       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_EXPANDED);
10969       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_COLLAPSED);
10970
10971       tree_view->priv->expanded_collapsed_node = NULL;
10972     }
10973
10974   if (animate)
10975     {
10976       tree_view->priv->expand_collapse_timeout = g_timeout_add (50, expand_collapse_timeout, tree_view);
10977       tree_view->priv->expanded_collapsed_node = node;
10978       tree_view->priv->expanded_collapsed_tree = tree;
10979
10980       GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
10981     }
10982
10983   if (GTK_WIDGET_MAPPED (tree_view))
10984     {
10985       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
10986     }
10987
10988   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
10989
10990   if (GTK_WIDGET_MAPPED (tree_view))
10991     {
10992       /* now that we've collapsed all rows, we want to try to set the prelight
10993        * again. To do this, we fake a motion event and send it to ourselves. */
10994
10995       display = gdk_drawable_get_display (tree_view->priv->bin_window);
10996       child = tree_view->priv->bin_window;
10997       parent = gdk_window_get_parent (child);
10998
10999       if (gdk_window_get_pointer (parent, &x, &y, NULL) == child)
11000         {
11001           GdkEventMotion event;
11002           gint child_x, child_y;
11003
11004           gdk_window_get_position (child, &child_x, &child_y);
11005
11006           event.window = tree_view->priv->bin_window;
11007           event.x = x - child_x;
11008           event.y = y - child_y;
11009
11010           /* despite the fact this isn't a real event, I'm almost positive it will
11011            * never trigger a drag event.  maybe_drag is the only function that uses
11012            * more than just event.x and event.y. */
11013           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
11014         }
11015     }
11016
11017   return TRUE;
11018 }
11019
11020 /**
11021  * gtk_tree_view_collapse_row:
11022  * @tree_view: a #GtkTreeView
11023  * @path: path to a row in the @tree_view
11024  *
11025  * Collapses a row (hides its child rows, if they exist).
11026  *
11027  * Return value: %TRUE if the row was collapsed.
11028  **/
11029 gboolean
11030 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
11031                             GtkTreePath *path)
11032 {
11033   GtkRBTree *tree;
11034   GtkRBNode *node;
11035
11036   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11037   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
11038   g_return_val_if_fail (path != NULL, FALSE);
11039
11040   if (_gtk_tree_view_find_node (tree_view,
11041                                 path,
11042                                 &tree,
11043                                 &node))
11044     return FALSE;
11045
11046   if (tree == NULL || node->children == NULL)
11047     return FALSE;
11048
11049   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
11050 }
11051
11052 static void
11053 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
11054                                         GtkRBTree              *tree,
11055                                         GtkTreePath            *path,
11056                                         GtkTreeViewMappingFunc  func,
11057                                         gpointer                user_data)
11058 {
11059   GtkRBNode *node;
11060
11061   if (tree == NULL || tree->root == NULL)
11062     return;
11063
11064   node = tree->root;
11065
11066   while (node && node->left != tree->nil)
11067     node = node->left;
11068
11069   while (node)
11070     {
11071       if (node->children)
11072         {
11073           (* func) (tree_view, path, user_data);
11074           gtk_tree_path_down (path);
11075           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
11076           gtk_tree_path_up (path);
11077         }
11078       gtk_tree_path_next (path);
11079       node = _gtk_rbtree_next (tree, node);
11080     }
11081 }
11082
11083 /**
11084  * gtk_tree_view_map_expanded_rows:
11085  * @tree_view: A #GtkTreeView
11086  * @func: A function to be called
11087  * @data: User data to be passed to the function.
11088  *
11089  * Calls @func on all expanded rows.
11090  **/
11091 void
11092 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
11093                                  GtkTreeViewMappingFunc  func,
11094                                  gpointer                user_data)
11095 {
11096   GtkTreePath *path;
11097
11098   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11099   g_return_if_fail (func != NULL);
11100
11101   path = gtk_tree_path_new_first ();
11102
11103   gtk_tree_view_map_expanded_rows_helper (tree_view,
11104                                           tree_view->priv->tree,
11105                                           path, func, user_data);
11106
11107   gtk_tree_path_free (path);
11108 }
11109
11110 /**
11111  * gtk_tree_view_row_expanded:
11112  * @tree_view: A #GtkTreeView.
11113  * @path: A #GtkTreePath to test expansion state.
11114  *
11115  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
11116  *
11117  * Return value: %TRUE if #path is expanded.
11118  **/
11119 gboolean
11120 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
11121                             GtkTreePath *path)
11122 {
11123   GtkRBTree *tree;
11124   GtkRBNode *node;
11125
11126   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11127   g_return_val_if_fail (path != NULL, FALSE);
11128
11129   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
11130
11131   if (node == NULL)
11132     return FALSE;
11133
11134   return (node->children != NULL);
11135 }
11136
11137 static const GtkTargetEntry row_targets[] = {
11138   { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
11139 };
11140
11141
11142 /**
11143  * gtk_tree_view_get_reorderable:
11144  * @tree_view: a #GtkTreeView
11145  *
11146  * Retrieves whether the user can reorder the tree via drag-and-drop. See
11147  * gtk_tree_view_set_reorderable().
11148  *
11149  * Return value: %TRUE if the tree can be reordered.
11150  **/
11151 gboolean
11152 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
11153 {
11154   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11155
11156   return tree_view->priv->reorderable;
11157 }
11158
11159 /**
11160  * gtk_tree_view_set_reorderable:
11161  * @tree_view: A #GtkTreeView.
11162  * @reorderable: %TRUE, if the tree can be reordered.
11163  *
11164  * This function is a convenience function to allow you to reorder models that
11165  * support the #GtkDragSourceIface and the #GtkDragDestIface.  Both
11166  * #GtkTreeStore and #GtkListStore support these.  If @reorderable is %TRUE, then
11167  * the user can reorder the model by dragging and dropping rows.  The
11168  * developer can listen to these changes by connecting to the model's
11169  * row_inserted and row_deleted signals.
11170  *
11171  * This function does not give you any degree of control over the order -- any
11172  * reordering is allowed.  If more control is needed, you should probably
11173  * handle drag and drop manually.
11174  **/
11175 void
11176 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
11177                                gboolean     reorderable)
11178 {
11179   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11180
11181   reorderable = reorderable != FALSE;
11182
11183   if (tree_view->priv->reorderable == reorderable)
11184     return;
11185
11186   if (reorderable)
11187     {
11188       gtk_tree_view_enable_model_drag_source (tree_view,
11189                                               GDK_BUTTON1_MASK,
11190                                               row_targets,
11191                                               G_N_ELEMENTS (row_targets),
11192                                               GDK_ACTION_MOVE);
11193       gtk_tree_view_enable_model_drag_dest (tree_view,
11194                                             row_targets,
11195                                             G_N_ELEMENTS (row_targets),
11196                                             GDK_ACTION_MOVE);
11197     }
11198   else
11199     {
11200       gtk_tree_view_unset_rows_drag_source (tree_view);
11201       gtk_tree_view_unset_rows_drag_dest (tree_view);
11202     }
11203
11204   tree_view->priv->reorderable = reorderable;
11205
11206   g_object_notify (G_OBJECT (tree_view), "reorderable");
11207 }
11208
11209 static void
11210 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
11211                                GtkTreePath     *path,
11212                                gboolean         clear_and_select,
11213                                gboolean         clamp_node)
11214 {
11215   GtkRBTree *tree = NULL;
11216   GtkRBNode *node = NULL;
11217
11218   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
11219     {
11220       GtkTreePath *cursor_path;
11221       cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
11222       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
11223       gtk_tree_path_free (cursor_path);
11224     }
11225
11226   gtk_tree_row_reference_free (tree_view->priv->cursor);
11227
11228   tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
11229                                                               tree_view->priv->model,
11230                                                               path);
11231   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
11232   if (tree != NULL)
11233     {
11234       GtkRBTree *new_tree = NULL;
11235       GtkRBNode *new_node = NULL;
11236
11237       if (clear_and_select && !tree_view->priv->ctrl_pressed)
11238         {
11239           GtkTreeSelectMode mode = 0;
11240
11241           if (tree_view->priv->ctrl_pressed)
11242             mode |= GTK_TREE_SELECT_MODE_TOGGLE;
11243           if (tree_view->priv->shift_pressed)
11244             mode |= GTK_TREE_SELECT_MODE_EXTEND;
11245
11246           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
11247                                                     node, tree, path, mode,
11248                                                     FALSE);
11249         }
11250
11251       /* We have to re-find tree and node here again, somebody might have
11252        * cleared the node or the whole tree in the GtkTreeSelection::changed
11253        * callback. If the nodes differ we bail out here.
11254        */
11255       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
11256
11257       if (tree != new_tree || node != new_node)
11258         return;
11259
11260       if (clamp_node)
11261         {
11262           gtk_tree_view_clamp_node_visible (tree_view, tree, node);
11263           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
11264         }
11265     }
11266
11267   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
11268 }
11269
11270 /**
11271  * gtk_tree_view_get_cursor:
11272  * @tree_view: A #GtkTreeView
11273  * @path: A pointer to be filled with the current cursor path, or %NULL
11274  * @focus_column: A pointer to be filled with the current focus column, or %NULL
11275  *
11276  * Fills in @path and @focus_column with the current path and focus column.  If
11277  * the cursor isn't currently set, then *@path will be %NULL.  If no column
11278  * currently has focus, then *@focus_column will be %NULL.
11279  *
11280  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
11281  * you are done with it.
11282  **/
11283 void
11284 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
11285                           GtkTreePath       **path,
11286                           GtkTreeViewColumn **focus_column)
11287 {
11288   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11289
11290   if (path)
11291     {
11292       if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
11293         *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
11294       else
11295         *path = NULL;
11296     }
11297
11298   if (focus_column)
11299     {
11300       *focus_column = tree_view->priv->focus_column;
11301     }
11302 }
11303
11304 /**
11305  * gtk_tree_view_set_cursor:
11306  * @tree_view: A #GtkTreeView
11307  * @path: A #GtkTreePath
11308  * @focus_column: A #GtkTreeViewColumn, or %NULL
11309  * @start_editing: %TRUE if the specified cell should start being edited.
11310  *
11311  * Sets the current keyboard focus to be at @path, and selects it.  This is
11312  * useful when you want to focus the user's attention on a particular row.  If
11313  * @focus_column is not %NULL, then focus is given to the column specified by
11314  * it. Additionally, if @focus_column is specified, and @start_editing is
11315  * %TRUE, then editing should be started in the specified cell.
11316  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
11317  * in order to give keyboard focus to the widget.  Please note that editing
11318  * can only happen when the widget is realized.
11319  **/
11320 void
11321 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
11322                           GtkTreePath       *path,
11323                           GtkTreeViewColumn *focus_column,
11324                           gboolean           start_editing)
11325 {
11326   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
11327                                     NULL, start_editing);
11328 }
11329
11330 /**
11331  * gtk_tree_view_set_cursor_on_cell:
11332  * @tree_view: A #GtkTreeView
11333  * @path: A #GtkTreePath
11334  * @focus_column: A #GtkTreeViewColumn, or %NULL
11335  * @focus_cell: A #GtkCellRenderer, or %NULL
11336  * @start_editing: %TRUE if the specified cell should start being edited.
11337  *
11338  * Sets the current keyboard focus to be at @path, and selects it.  This is
11339  * useful when you want to focus the user's attention on a particular row.  If
11340  * @focus_column is not %NULL, then focus is given to the column specified by
11341  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
11342  * contains 2 or more editable or activatable cells, then focus is given to
11343  * the cell specified by @focus_cell. Additionally, if @focus_column is
11344  * specified, and @start_editing is %TRUE, then editing should be started in
11345  * the specified cell.  This function is often followed by
11346  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
11347  * widget.  Please note that editing can only happen when the widget is
11348  * realized.
11349  *
11350  * Since: 2.2
11351  **/
11352 void
11353 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
11354                                   GtkTreePath       *path,
11355                                   GtkTreeViewColumn *focus_column,
11356                                   GtkCellRenderer   *focus_cell,
11357                                   gboolean           start_editing)
11358 {
11359   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11360   g_return_if_fail (path != NULL);
11361   if (focus_column)
11362     g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (focus_column));
11363   if (focus_cell)
11364     {
11365       g_return_if_fail (focus_column);
11366       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
11367     }
11368
11369   /* cancel the current editing, if it exists */
11370   if (tree_view->priv->edited_column &&
11371       tree_view->priv->edited_column->editable_widget)
11372     gtk_tree_view_stop_editing (tree_view, TRUE);
11373
11374   gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
11375
11376   if (focus_column && focus_column->visible)
11377     {
11378       GList *list;
11379       gboolean column_in_tree = FALSE;
11380
11381       for (list = tree_view->priv->columns; list; list = list->next)
11382         if (list->data == focus_column)
11383           {
11384             column_in_tree = TRUE;
11385             break;
11386           }
11387       g_return_if_fail (column_in_tree);
11388       tree_view->priv->focus_column = focus_column;
11389       if (focus_cell)
11390         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
11391       if (start_editing)
11392         gtk_tree_view_start_editing (tree_view, path);
11393     }
11394 }
11395
11396 /**
11397  * gtk_tree_view_get_bin_window:
11398  * @tree_view: A #GtkTreeView
11399  *
11400  * Returns the window that @tree_view renders to.  This is used primarily to
11401  * compare to <literal>event->window</literal> to confirm that the event on
11402  * @tree_view is on the right window.
11403  *
11404  * Return value: A #GdkWindow, or %NULL when @tree_view hasn't been realized yet
11405  **/
11406 GdkWindow *
11407 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
11408 {
11409   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11410
11411   return tree_view->priv->bin_window;
11412 }
11413
11414 /**
11415  * gtk_tree_view_get_path_at_pos:
11416  * @tree_view: A #GtkTreeView.
11417  * @x: The x position to be identified.
11418  * @y: The y position to be identified.
11419  * @path: A pointer to a #GtkTreePath pointer to be filled in, or %NULL
11420  * @column: A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
11421  * @cell_x: A pointer where the X coordinate relative to the cell can be placed, or %NULL
11422  * @cell_y: A pointer where the Y coordinate relative to the cell can be placed, or %NULL
11423  *
11424  * Finds the path at the point (@x, @y), relative to widget coordinates.  That
11425  * is, @x and @y are relative to an events coordinates. @x and @y must come
11426  * from an event on the @tree_view only where <literal>event->window ==
11427  * gtk_tree_view_get_bin (<!-- -->)</literal>. It is primarily for things
11428  * like popup menus. If @path is non-%NULL, then it will be filled with the
11429  * #GtkTreePath at that point.  This path should be freed with gtk_tree_path_free().
11430  * If @column is non-%NULL, then it will be filled with the column at that point.
11431  * @cell_x and @cell_y return the coordinates relative to the cell background
11432  * (i.e. the @background_area passed to gtk_cell_renderer_render()).  This
11433  * function is only meaningful if @tree_view is realized.
11434  *
11435  * Return value: %TRUE if a row exists at that coordinate.
11436  **/
11437 gboolean
11438 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
11439                                gint                x,
11440                                gint                y,
11441                                GtkTreePath       **path,
11442                                GtkTreeViewColumn **column,
11443                                gint               *cell_x,
11444                                gint               *cell_y)
11445 {
11446   GtkRBTree *tree;
11447   GtkRBNode *node;
11448   gint y_offset;
11449
11450   g_return_val_if_fail (tree_view != NULL, FALSE);
11451   g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
11452
11453   if (path)
11454     *path = NULL;
11455   if (column)
11456     *column = NULL;
11457
11458   if (tree_view->priv->tree == NULL)
11459     return FALSE;
11460
11461   if (x > tree_view->priv->hadjustment->upper)
11462     return FALSE;
11463
11464   if (x < 0 || y < 0)
11465     return FALSE;
11466
11467   if (column || cell_x)
11468     {
11469       GtkTreeViewColumn *tmp_column;
11470       GtkTreeViewColumn *last_column = NULL;
11471       GList *list;
11472       gint remaining_x = x;
11473       gboolean found = FALSE;
11474       gboolean rtl;
11475
11476       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
11477       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
11478            list;
11479            list = (rtl ? list->prev : list->next))
11480         {
11481           tmp_column = list->data;
11482
11483           if (tmp_column->visible == FALSE)
11484             continue;
11485
11486           last_column = tmp_column;
11487           if (remaining_x <= tmp_column->width)
11488             {
11489               found = TRUE;
11490
11491               if (column)
11492                 *column = tmp_column;
11493
11494               if (cell_x)
11495                 *cell_x = remaining_x;
11496
11497               break;
11498             }
11499           remaining_x -= tmp_column->width;
11500         }
11501
11502       /* If found is FALSE and there is a last_column, then it the remainder
11503        * space is in that area
11504        */
11505       if (!found)
11506         {
11507           if (last_column)
11508             {
11509               if (column)
11510                 *column = last_column;
11511
11512               if (cell_x)
11513                 *cell_x = last_column->width + remaining_x;
11514             }
11515           else
11516             {
11517               return FALSE;
11518             }
11519         }
11520     }
11521
11522   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
11523                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
11524                                       &tree, &node);
11525
11526   if (tree == NULL)
11527     return FALSE;
11528
11529   if (cell_y)
11530     *cell_y = y_offset;
11531
11532   if (path)
11533     *path = _gtk_tree_view_find_path (tree_view, tree, node);
11534
11535   return TRUE;
11536 }
11537
11538
11539 /**
11540  * gtk_tree_view_get_cell_area:
11541  * @tree_view: a #GtkTreeView
11542  * @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
11543  * @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
11544  * @rect: rectangle to fill with cell rect
11545  *
11546  * Fills the bounding rectangle in tree window coordinates for the cell at the
11547  * row specified by @path and the column specified by @column.  If @path is
11548  * %NULL, or points to a path not currently displayed, the @y and @height fields
11549  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
11550  * fields will be filled with 0.  The sum of all cell rects does not cover the
11551  * entire tree; there are extra pixels in between rows, for example. The
11552  * returned rectangle is equivalent to the @cell_area passed to
11553  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
11554  * realized.
11555  **/
11556 void
11557 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
11558                              GtkTreePath        *path,
11559                              GtkTreeViewColumn  *column,
11560                              GdkRectangle       *rect)
11561 {
11562   GtkRBTree *tree = NULL;
11563   GtkRBNode *node = NULL;
11564   gint vertical_separator;
11565   gint horizontal_separator;
11566
11567   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11568   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
11569   g_return_if_fail (rect != NULL);
11570   g_return_if_fail (!column || column->tree_view == (GtkWidget *) tree_view);
11571   g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
11572
11573   gtk_widget_style_get (GTK_WIDGET (tree_view),
11574                         "vertical-separator", &vertical_separator,
11575                         "horizontal-separator", &horizontal_separator,
11576                         NULL);
11577
11578   rect->x = 0;
11579   rect->y = 0;
11580   rect->width = 0;
11581   rect->height = 0;
11582
11583   if (column)
11584     {
11585       rect->x = column->button->allocation.x + horizontal_separator/2;
11586       rect->width = column->button->allocation.width - horizontal_separator;
11587     }
11588
11589   if (path)
11590     {
11591       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
11592
11593       /* Get vertical coords */
11594       if ((!ret && tree == NULL) || ret)
11595         return;
11596
11597       rect->y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
11598       rect->height = MAX (CELL_HEIGHT (node, vertical_separator), tree_view->priv->expander_size - vertical_separator);
11599
11600       if (column &&
11601           gtk_tree_view_is_expander_column (tree_view, column) &&
11602           TREE_VIEW_DRAW_EXPANDERS (tree_view))
11603         {
11604           gint depth = gtk_tree_path_get_depth (path) - 1;
11605
11606           rect->x += depth * tree_view->priv->expander_size;
11607           rect->width -= depth * tree_view->priv->expander_size;
11608           rect->width = MAX (rect->width, 0);
11609         }
11610     }
11611 }
11612
11613 /**
11614  * gtk_tree_view_get_background_area:
11615  * @tree_view: a #GtkTreeView
11616  * @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
11617  * @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
11618  * @rect: rectangle to fill with cell background rect
11619  *
11620  * Fills the bounding rectangle in tree window coordinates for the cell at the
11621  * row specified by @path and the column specified by @column.  If @path is
11622  * %NULL, or points to a node not found in the tree, the @y and @height fields of
11623  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
11624  * fields will be filled with 0.  The returned rectangle is equivalent to the
11625  * @background_area passed to gtk_cell_renderer_render().  These background
11626  * areas tile to cover the entire tree window (except for the area used for
11627  * header buttons). Contrast with the @cell_area, returned by
11628  * gtk_tree_view_get_cell_area(), which returns only the cell itself, excluding
11629  * surrounding borders and the tree expander area.
11630  *
11631  **/
11632 void
11633 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
11634                                    GtkTreePath        *path,
11635                                    GtkTreeViewColumn  *column,
11636                                    GdkRectangle       *rect)
11637 {
11638   GtkRBTree *tree = NULL;
11639   GtkRBNode *node = NULL;
11640
11641   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11642   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
11643   g_return_if_fail (rect != NULL);
11644
11645   rect->x = 0;
11646   rect->y = 0;
11647   rect->width = 0;
11648   rect->height = 0;
11649
11650   if (path)
11651     {
11652       /* Get vertical coords */
11653
11654       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
11655           tree == NULL)
11656         return;
11657
11658       rect->y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
11659
11660       rect->height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
11661     }
11662
11663   if (column)
11664     {
11665       gint x2 = 0;
11666
11667       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
11668       rect->width = x2 - rect->x;
11669     }
11670 }
11671
11672 /**
11673  * gtk_tree_view_get_visible_rect:
11674  * @tree_view: a #GtkTreeView
11675  * @visible_rect: rectangle to fill
11676  *
11677  * Fills @visible_rect with the currently-visible region of the
11678  * buffer, in tree coordinates. Convert to widget coordinates with
11679  * gtk_tree_view_tree_to_widget_coords(). Tree coordinates start at
11680  * 0,0 for row 0 of the tree, and cover the entire scrollable area of
11681  * the tree.
11682  **/
11683 void
11684 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
11685                                 GdkRectangle *visible_rect)
11686 {
11687   GtkWidget *widget;
11688
11689   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11690
11691   widget = GTK_WIDGET (tree_view);
11692
11693   if (visible_rect)
11694     {
11695       visible_rect->x = tree_view->priv->hadjustment->value;
11696       visible_rect->y = tree_view->priv->vadjustment->value;
11697       visible_rect->width = widget->allocation.width;
11698       visible_rect->height = widget->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
11699     }
11700 }
11701
11702 /**
11703  * gtk_tree_view_widget_to_tree_coords:
11704  * @tree_view: a #GtkTreeView
11705  * @wx: widget X coordinate
11706  * @wy: widget Y coordinate
11707  * @tx: return location for tree X coordinate
11708  * @ty: return location for tree Y coordinate
11709  *
11710  * Converts widget coordinates to coordinates for the
11711  * tree window (the full scrollable area of the tree).
11712  *
11713  **/
11714 void
11715 gtk_tree_view_widget_to_tree_coords (GtkTreeView *tree_view,
11716                                       gint         wx,
11717                                       gint         wy,
11718                                       gint        *tx,
11719                                       gint        *ty)
11720 {
11721   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11722
11723   if (tx)
11724     *tx = wx + tree_view->priv->hadjustment->value;
11725   if (ty)
11726     *ty = wy + tree_view->priv->dy;
11727 }
11728
11729 static void
11730 gtk_tree_view_tree_window_to_tree_coords (GtkTreeView *tree_view,
11731                                           gint         wx,
11732                                           gint         wy,
11733                                           gint        *tx,
11734                                           gint        *ty)
11735 {
11736   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11737
11738   if (tx)
11739     *tx = wx;
11740   if (ty)
11741     *ty = wy + tree_view->priv->dy;
11742 }
11743
11744 /**
11745  * gtk_tree_view_tree_to_widget_coords:
11746  * @tree_view: a #GtkTreeView
11747  * @tx: tree X coordinate
11748  * @ty: tree Y coordinate
11749  * @wx: return location for widget X coordinate
11750  * @wy: return location for widget Y coordinate
11751  *
11752  * Converts tree coordinates (coordinates in full scrollable area of the tree)
11753  * to widget coordinates.
11754  *
11755  **/
11756 void
11757 gtk_tree_view_tree_to_widget_coords (GtkTreeView *tree_view,
11758                                      gint         tx,
11759                                      gint         ty,
11760                                      gint        *wx,
11761                                      gint        *wy)
11762 {
11763   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11764
11765   if (wx)
11766     *wx = tx - tree_view->priv->hadjustment->value;
11767   if (wy)
11768     *wy = ty - tree_view->priv->dy;
11769 }
11770
11771 static void
11772 unset_reorderable (GtkTreeView *tree_view)
11773 {
11774   if (tree_view->priv->reorderable)
11775     {
11776       tree_view->priv->reorderable = FALSE;
11777       g_object_notify (G_OBJECT (tree_view), "reorderable");
11778     }
11779 }
11780
11781 /**
11782  * gtk_tree_view_enable_model_drag_source:
11783  * @tree_view: a #GtkTreeView
11784  * @start_button_mask: Mask of allowed buttons to start drag
11785  * @targets: the table of targets that the drag will support
11786  * @n_targets: the number of items in @targets
11787  * @actions: the bitmask of possible actions for a drag from this
11788  *    widget
11789  *
11790  * Turns @tree_view into a drag source for automatic DND.
11791  **/
11792 void
11793 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
11794                                         GdkModifierType           start_button_mask,
11795                                         const GtkTargetEntry     *targets,
11796                                         gint                      n_targets,
11797                                         GdkDragAction             actions)
11798 {
11799   TreeViewDragInfo *di;
11800
11801   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11802
11803   gtk_drag_source_set (GTK_WIDGET (tree_view),
11804                        0,
11805                        targets,
11806                        n_targets,
11807                        actions);
11808
11809   di = ensure_info (tree_view);
11810   clear_source_info (di);
11811
11812   di->start_button_mask = start_button_mask;
11813   di->source_target_list = gtk_target_list_new (targets, n_targets);
11814   di->source_actions = actions;
11815
11816   di->source_set = TRUE;
11817
11818   unset_reorderable (tree_view);
11819 }
11820
11821 /**
11822  * gtk_tree_view_enable_model_drag_dest:
11823  * @tree_view: a #GtkTreeView
11824  * @targets: the table of targets that the drag will support
11825  * @n_targets: the number of items in @targets
11826  * @actions: the bitmask of possible actions for a drag from this
11827  *    widget
11828  *
11829  * Turns @tree_view into a drop destination for automatic DND.
11830  **/
11831 void
11832 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
11833                                       const GtkTargetEntry     *targets,
11834                                       gint                      n_targets,
11835                                       GdkDragAction             actions)
11836 {
11837   TreeViewDragInfo *di;
11838
11839   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11840
11841   gtk_drag_dest_set (GTK_WIDGET (tree_view),
11842                      0,
11843                      targets,
11844                      n_targets,
11845                      actions);
11846
11847   di = ensure_info (tree_view);
11848   clear_dest_info (di);
11849
11850   if (targets)
11851     di->dest_target_list = gtk_target_list_new (targets, n_targets);
11852
11853   di->dest_set = TRUE;
11854
11855   unset_reorderable (tree_view);
11856 }
11857
11858 /**
11859  * gtk_tree_view_unset_rows_drag_source:
11860  * @tree_view: a #GtkTreeView
11861  *
11862  * Undoes the effect of gtk_tree_view_enable_model_drag_source().
11863  **/
11864 void
11865 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
11866 {
11867   TreeViewDragInfo *di;
11868
11869   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11870
11871   di = get_info (tree_view);
11872
11873   if (di)
11874     {
11875       if (di->source_set)
11876         {
11877           gtk_drag_source_unset (GTK_WIDGET (tree_view));
11878           clear_source_info (di);
11879           di->source_set = FALSE;
11880         }
11881
11882       if (!di->dest_set && !di->source_set)
11883         remove_info (tree_view);
11884     }
11885
11886   unset_reorderable (tree_view);
11887 }
11888
11889 /**
11890  * gtk_tree_view_unset_rows_drag_dest:
11891  * @tree_view: a #GtkTreeView
11892  *
11893  * Undoes the effect of gtk_tree_view_enable_model_drag_dest().
11894  **/
11895 void
11896 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
11897 {
11898   TreeViewDragInfo *di;
11899
11900   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11901
11902   di = get_info (tree_view);
11903
11904   if (di)
11905     {
11906       if (di->dest_set)
11907         {
11908           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
11909           clear_dest_info (di);
11910           di->dest_set = FALSE;
11911         }
11912
11913       if (!di->dest_set && !di->source_set)
11914         remove_info (tree_view);
11915     }
11916
11917   unset_reorderable (tree_view);
11918 }
11919
11920 /**
11921  * gtk_tree_view_set_drag_dest_row:
11922  * @tree_view: a #GtkTreeView
11923  * @path: The path of the row to highlight, or %NULL.
11924  * @pos: Specifies whether to drop before, after or into the row
11925  *
11926  * Sets the row that is highlighted for feedback.
11927  **/
11928 void
11929 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
11930                                  GtkTreePath            *path,
11931                                  GtkTreeViewDropPosition pos)
11932 {
11933   GtkTreePath *current_dest;
11934
11935   /* Note; this function is exported to allow a custom DND
11936    * implementation, so it can't touch TreeViewDragInfo
11937    */
11938
11939   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11940
11941   current_dest = NULL;
11942
11943   if (tree_view->priv->drag_dest_row)
11944     {
11945       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
11946       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
11947     }
11948
11949   /* special case a drop on an empty model */
11950   tree_view->priv->empty_view_drop = 0;
11951
11952   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
11953       && gtk_tree_path_get_depth (path) == 1
11954       && gtk_tree_path_get_indices (path)[0] == 0)
11955     {
11956       gint n_children;
11957
11958       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
11959                                                    NULL);
11960
11961       if (!n_children)
11962         tree_view->priv->empty_view_drop = 1;
11963     }
11964
11965   tree_view->priv->drag_dest_pos = pos;
11966
11967   if (path)
11968     {
11969       tree_view->priv->drag_dest_row =
11970         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
11971       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
11972     }
11973   else
11974     tree_view->priv->drag_dest_row = NULL;
11975
11976   if (current_dest)
11977     {
11978       GtkRBTree *tree, *new_tree;
11979       GtkRBNode *node, *new_node;
11980
11981       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
11982       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
11983
11984       if (tree && node)
11985         {
11986           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
11987           if (new_tree && new_node)
11988             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
11989
11990           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
11991           if (new_tree && new_node)
11992             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
11993         }
11994       gtk_tree_path_free (current_dest);
11995     }
11996 }
11997
11998 /**
11999  * gtk_tree_view_get_drag_dest_row:
12000  * @tree_view: a #GtkTreeView
12001  * @path: Return location for the path of the highlighted row, or %NULL.
12002  * @pos: Return location for the drop position, or %NULL
12003  *
12004  * Gets information about the row that is highlighted for feedback.
12005  **/
12006 void
12007 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
12008                                  GtkTreePath             **path,
12009                                  GtkTreeViewDropPosition  *pos)
12010 {
12011   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12012
12013   if (path)
12014     {
12015       if (tree_view->priv->drag_dest_row)
12016         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
12017       else
12018         {
12019           if (tree_view->priv->empty_view_drop)
12020             *path = gtk_tree_path_new_from_indices (0, -1);
12021           else
12022             *path = NULL;
12023         }
12024     }
12025
12026   if (pos)
12027     *pos = tree_view->priv->drag_dest_pos;
12028 }
12029
12030 /**
12031  * gtk_tree_view_get_dest_row_at_pos:
12032  * @tree_view: a #GtkTreeView
12033  * @drag_x: the position to determine the destination row for
12034  * @drag_y: the position to determine the destination row for
12035  * @path: Return location for the path of the highlighted row, or %NULL.
12036  * @pos: Return location for the drop position, or %NULL
12037  *
12038  * Determines the destination row for a given position.
12039  *
12040  * Return value: whether there is a row at the given position.
12041  **/
12042 gboolean
12043 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
12044                                    gint                     drag_x,
12045                                    gint                     drag_y,
12046                                    GtkTreePath            **path,
12047                                    GtkTreeViewDropPosition *pos)
12048 {
12049   gint cell_y;
12050   gdouble offset_into_row;
12051   gdouble third;
12052   GdkRectangle cell;
12053   GtkTreeViewColumn *column = NULL;
12054   GtkTreePath *tmp_path = NULL;
12055
12056   /* Note; this function is exported to allow a custom DND
12057    * implementation, so it can't touch TreeViewDragInfo
12058    */
12059
12060   g_return_val_if_fail (tree_view != NULL, FALSE);
12061   g_return_val_if_fail (drag_x >= 0, FALSE);
12062   g_return_val_if_fail (drag_y >= 0, FALSE);
12063   g_return_val_if_fail (tree_view->priv->bin_window != NULL, FALSE);
12064
12065
12066   if (path)
12067     *path = NULL;
12068
12069   if (tree_view->priv->tree == NULL)
12070     return FALSE;
12071
12072   /* If in the top third of a row, we drop before that row; if
12073    * in the bottom third, drop after that row; if in the middle,
12074    * and the row has children, drop into the row.
12075    */
12076
12077   if (!gtk_tree_view_get_path_at_pos (tree_view,
12078                                       drag_x,
12079                                       drag_y - TREE_VIEW_HEADER_HEIGHT (tree_view),
12080                                       &tmp_path,
12081                                       &column,
12082                                       NULL,
12083                                       &cell_y))
12084     return FALSE;
12085
12086   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
12087                                      &cell);
12088
12089   offset_into_row = cell_y;
12090
12091   if (path)
12092     *path = tmp_path;
12093   else
12094     gtk_tree_path_free (tmp_path);
12095
12096   tmp_path = NULL;
12097
12098   third = cell.height / 3.0;
12099
12100   if (pos)
12101     {
12102       if (offset_into_row < third)
12103         {
12104           *pos = GTK_TREE_VIEW_DROP_BEFORE;
12105         }
12106       else if (offset_into_row < (cell.height / 2.0))
12107         {
12108           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
12109         }
12110       else if (offset_into_row < third * 2.0)
12111         {
12112           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
12113         }
12114       else
12115         {
12116           *pos = GTK_TREE_VIEW_DROP_AFTER;
12117         }
12118     }
12119
12120   return TRUE;
12121 }
12122
12123
12124
12125 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
12126 /**
12127  * gtk_tree_view_create_row_drag_icon:
12128  * @tree_view: a #GtkTreeView
12129  * @path: a #GtkTreePath in @tree_view
12130  *
12131  * Creates a #GdkPixmap representation of the row at @path.  This image is used
12132  * for a drag icon.
12133  *
12134  * Return value: a newly-allocated pixmap of the drag icon.
12135  **/
12136 GdkPixmap *
12137 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
12138                                     GtkTreePath  *path)
12139 {
12140   GtkTreeIter   iter;
12141   GtkRBTree    *tree;
12142   GtkRBNode    *node;
12143   gint cell_offset;
12144   GList *list;
12145   GdkRectangle background_area;
12146   GdkRectangle expose_area;
12147   GtkWidget *widget;
12148   gint depth;
12149   /* start drawing inside the black outline */
12150   gint x = 1, y = 1;
12151   GdkDrawable *drawable;
12152   gint bin_window_width;
12153   gboolean is_separator = FALSE;
12154
12155   widget = GTK_WIDGET (tree_view);
12156
12157   depth = gtk_tree_path_get_depth (path);
12158
12159   _gtk_tree_view_find_node (tree_view,
12160                             path,
12161                             &tree,
12162                             &node);
12163
12164   if (tree == NULL)
12165     return NULL;
12166
12167   if (!gtk_tree_model_get_iter (tree_view->priv->model,
12168                                 &iter,
12169                                 path))
12170     return NULL;
12171
12172   if (tree_view->priv->row_separator_func)
12173     {
12174       is_separator = (* tree_view->priv->row_separator_func) (tree_view->priv->model,
12175                                                               &iter,
12176                                                               tree_view->priv->row_separator_data);
12177     }
12178
12179   cell_offset = x;
12180
12181   background_area.y = y;
12182   background_area.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
12183
12184   gdk_drawable_get_size (tree_view->priv->bin_window,
12185                          &bin_window_width, NULL);
12186
12187   drawable = gdk_pixmap_new (tree_view->priv->bin_window,
12188                              bin_window_width + 2,
12189                              background_area.height + 2,
12190                              -1);
12191
12192   expose_area.x = 0;
12193   expose_area.y = 0;
12194   expose_area.width = bin_window_width + 2;
12195   expose_area.height = background_area.height + 2;
12196
12197   gdk_draw_rectangle (drawable,
12198                       widget->style->base_gc [GTK_WIDGET_STATE (widget)],
12199                       TRUE,
12200                       0, 0,
12201                       bin_window_width + 2,
12202                       background_area.height + 2);
12203
12204   for (list = tree_view->priv->columns; list; list = list->next)
12205     {
12206       GtkTreeViewColumn *column = list->data;
12207       GdkRectangle cell_area;
12208       gint vertical_separator;
12209
12210       if (!column->visible)
12211         continue;
12212
12213       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
12214                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
12215                                                node->children?TRUE:FALSE);
12216
12217       background_area.x = cell_offset;
12218       background_area.width = column->width;
12219
12220       cell_area = background_area;
12221
12222       gtk_widget_style_get (widget, "vertical-separator", &vertical_separator, NULL);
12223       cell_area.y += vertical_separator / 2;
12224       cell_area.height -= vertical_separator;
12225
12226       if (gtk_tree_view_is_expander_column (tree_view, column) &&
12227           TREE_VIEW_DRAW_EXPANDERS(tree_view))
12228         {
12229           cell_area.x += depth * tree_view->priv->expander_size;
12230           cell_area.width -= depth * tree_view->priv->expander_size;
12231         }
12232
12233       if (gtk_tree_view_column_cell_is_visible (column))
12234         {
12235           if (is_separator)
12236             gtk_paint_hline (widget->style,
12237                              drawable,
12238                              GTK_STATE_NORMAL,
12239                              &cell_area,
12240                              widget,
12241                              NULL,
12242                              cell_area.x,
12243                              cell_area.x + cell_area.width,
12244                              cell_area.y + cell_area.height / 2);
12245           else
12246             _gtk_tree_view_column_cell_render (column,
12247                                                drawable,
12248                                                &background_area,
12249                                                &cell_area,
12250                                                &expose_area,
12251                                                0);
12252         }
12253       cell_offset += column->width;
12254     }
12255
12256   gdk_draw_rectangle (drawable,
12257                       widget->style->black_gc,
12258                       FALSE,
12259                       0, 0,
12260                       bin_window_width + 1,
12261                       background_area.height + 1);
12262
12263   return drawable;
12264 }
12265
12266
12267 /**
12268  * gtk_tree_view_set_destroy_count_func:
12269  * @tree_view: A #GtkTreeView
12270  * @func: Function to be called when a view row is destroyed, or %NULL
12271  * @data: User data to be passed to @func, or %NULL
12272  * @destroy: Destroy notifier for @data, or %NULL
12273  *
12274  * This function should almost never be used.  It is meant for private use by
12275  * ATK for determining the number of visible children that are removed when the
12276  * user collapses a row, or a row is deleted.
12277  **/
12278 void
12279 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
12280                                       GtkTreeDestroyCountFunc  func,
12281                                       gpointer                 data,
12282                                       GtkDestroyNotify         destroy)
12283 {
12284   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12285
12286   if (tree_view->priv->destroy_count_destroy)
12287     (* tree_view->priv->destroy_count_destroy) (tree_view->priv->destroy_count_data);
12288
12289   tree_view->priv->destroy_count_func = func;
12290   tree_view->priv->destroy_count_data = data;
12291   tree_view->priv->destroy_count_destroy = destroy;
12292 }
12293
12294
12295 /*
12296  * Interactive search
12297  */
12298
12299 /**
12300  * gtk_tree_view_set_enable_search:
12301  * @tree_view: A #GtkTreeView
12302  * @enable_search: %TRUE, if the user can search interactively
12303  *
12304  * If @enable_search is set, then the user can type in text to search through
12305  * the tree interactively (this is sometimes called "typeahead find").
12306  *
12307  * Note that even if this is %FALSE, the user can still initiate a search
12308  * using the "start-interactive-search" key binding.
12309  */
12310 void
12311 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
12312                                  gboolean     enable_search)
12313 {
12314   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12315
12316   enable_search = !!enable_search;
12317
12318   if (tree_view->priv->enable_search != enable_search)
12319     {
12320        tree_view->priv->enable_search = enable_search;
12321        g_object_notify (G_OBJECT (tree_view), "enable-search");
12322     }
12323 }
12324
12325 /**
12326  * gtk_tree_view_get_enable_search:
12327  * @tree_view: A #GtkTreeView
12328  *
12329  * Returns whether or not the tree allows to start interactive searching
12330  * by typing in text.
12331  *
12332  * Return value: whether or not to let the user search interactively
12333  */
12334 gboolean
12335 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
12336 {
12337   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12338
12339   return tree_view->priv->enable_search;
12340 }
12341
12342
12343 /**
12344  * gtk_tree_view_get_search_column:
12345  * @tree_view: A #GtkTreeView
12346  *
12347  * Gets the column searched on by the interactive search code.
12348  *
12349  * Return value: the column the interactive search code searches in.
12350  */
12351 gint
12352 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
12353 {
12354   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12355
12356   return (tree_view->priv->search_column);
12357 }
12358
12359 /**
12360  * gtk_tree_view_set_search_column:
12361  * @tree_view: A #GtkTreeView
12362  * @column: the column of the model to search in, or -1 to disable searching
12363  *
12364  * Sets @column as the column where the interactive search code should
12365  * search in.
12366  *
12367  * If the sort column is set, users can use the "start-interactive-search"
12368  * key binding to bring up search popup. The enable-search property controls
12369  * whether simply typing text will also start an interactive search.
12370  *
12371  * Note that @column refers to a column of the model.
12372  */
12373 void
12374 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
12375                                  gint         column)
12376 {
12377   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12378   g_return_if_fail (column >= -1);
12379
12380   if (tree_view->priv->search_column == column)
12381     return;
12382
12383   tree_view->priv->search_column = column;
12384   g_object_notify (G_OBJECT (tree_view), "search-column");
12385 }
12386
12387 /**
12388  * gtk_tree_view_get_search_equal_func:
12389  * @tree_view: A #GtkTreeView
12390  *
12391  * Returns the compare function currently in use.
12392  *
12393  * Return value: the currently used compare function for the search code.
12394  */
12395
12396 GtkTreeViewSearchEqualFunc
12397 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
12398 {
12399   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12400
12401   return tree_view->priv->search_equal_func;
12402 }
12403
12404 /**
12405  * gtk_tree_view_set_search_equal_func:
12406  * @tree_view: A #GtkTreeView
12407  * @search_equal_func: the compare function to use during the search
12408  * @search_user_data: user data to pass to @search_equal_func, or %NULL
12409  * @search_destroy: Destroy notifier for @search_user_data, or %NULL
12410  *
12411  * Sets the compare function for the interactive search capabilities; note
12412  * that somewhat like strcmp() returning 0 for equality
12413  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
12414  **/
12415 void
12416 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
12417                                      GtkTreeViewSearchEqualFunc  search_equal_func,
12418                                      gpointer                    search_user_data,
12419                                      GtkDestroyNotify            search_destroy)
12420 {
12421   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12422   g_return_if_fail (search_equal_func !=NULL);
12423
12424   if (tree_view->priv->search_destroy)
12425     (* tree_view->priv->search_destroy) (tree_view->priv->search_user_data);
12426
12427   tree_view->priv->search_equal_func = search_equal_func;
12428   tree_view->priv->search_user_data = search_user_data;
12429   tree_view->priv->search_destroy = search_destroy;
12430   if (tree_view->priv->search_equal_func == NULL)
12431     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
12432 }
12433
12434 static void
12435 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
12436                                   GtkTreeView *tree_view)
12437 {
12438   if (tree_view->priv->disable_popdown)
12439     return;
12440
12441   if (tree_view->priv->search_entry_changed_id)
12442     {
12443       g_signal_handler_disconnect (tree_view->priv->search_entry,
12444                                    tree_view->priv->search_entry_changed_id);
12445       tree_view->priv->search_entry_changed_id = 0;
12446     }
12447   if (tree_view->priv->typeselect_flush_timeout)
12448     {
12449       g_source_remove (tree_view->priv->typeselect_flush_timeout);
12450       tree_view->priv->typeselect_flush_timeout = 0;
12451     }
12452
12453   /* send focus-in event */
12454   send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), FALSE);
12455   gtk_widget_hide (search_dialog);
12456   gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
12457 }
12458
12459 static void
12460 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
12461                                     GtkWidget   *search_dialog)
12462 {
12463   gint x, y;
12464   gint tree_x, tree_y;
12465   gint tree_width, tree_height;
12466   GdkWindow *tree_window = GTK_WIDGET (tree_view)->window;
12467   GdkScreen *screen = gdk_drawable_get_screen (tree_window);
12468   GtkRequisition requisition;
12469   gint monitor_num;
12470   GdkRectangle monitor;
12471
12472   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
12473   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
12474
12475   gtk_widget_realize (search_dialog);
12476
12477   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
12478   gdk_drawable_get_size (tree_window,
12479                          &tree_width,
12480                          &tree_height);
12481   gtk_widget_size_request (search_dialog, &requisition);
12482
12483   if (tree_x + tree_width - requisition.width > gdk_screen_get_width (screen))
12484     x = gdk_screen_get_width (screen) - requisition.width;
12485   else if (tree_x + tree_width - requisition.width < 0)
12486     x = 0;
12487   else
12488     x = tree_x + tree_width - requisition.width;
12489
12490   if (tree_y + tree_height > gdk_screen_get_height (screen))
12491     y = gdk_screen_get_height (screen) - requisition.height;
12492   else if (tree_y + tree_height < 0) /* isn't really possible ... */
12493     y = 0;
12494   else
12495     y = tree_y + tree_height;
12496
12497   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
12498 }
12499
12500 static void
12501 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
12502                                       GtkMenu  *menu,
12503                                       gpointer  data)
12504 {
12505   GtkTreeView *tree_view = (GtkTreeView *)data;
12506
12507   tree_view->priv->disable_popdown = 1;
12508   g_signal_connect (menu, "hide",
12509                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
12510 }
12511
12512 /* Because we're visible but offscreen, we just set a flag in the preedit
12513  * callback.
12514  */
12515 static void
12516 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
12517                                       GtkTreeView  *tree_view)
12518 {
12519   tree_view->priv->imcontext_changed = 1;
12520   if (tree_view->priv->typeselect_flush_timeout)
12521     {
12522       g_source_remove (tree_view->priv->typeselect_flush_timeout);
12523       tree_view->priv->typeselect_flush_timeout =
12524         g_timeout_add (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
12525                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
12526                        tree_view);
12527     }
12528
12529 }
12530
12531 static void
12532 gtk_tree_view_search_activate (GtkEntry    *entry,
12533                                GtkTreeView *tree_view)
12534 {
12535   GtkTreePath *path;
12536   GtkRBNode *node;
12537   GtkRBTree *tree;
12538
12539   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
12540                                     tree_view);
12541
12542   /* If we have a row selected and it's the cursor row, we activate
12543    * the row XXX */
12544   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12545     {
12546       path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12547
12548       _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12549
12550       if (node && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
12551         gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
12552
12553       gtk_tree_path_free (path);
12554     }
12555 }
12556
12557 static gboolean
12558 gtk_tree_view_real_search_enable_popdown (gpointer data)
12559 {
12560   GtkTreeView *tree_view = (GtkTreeView *)data;
12561
12562   GDK_THREADS_ENTER ();
12563
12564   tree_view->priv->disable_popdown = 0;
12565
12566   GDK_THREADS_LEAVE ();
12567
12568   return FALSE;
12569 }
12570
12571 static void
12572 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
12573                                      gpointer   data)
12574 {
12575   g_timeout_add (200, gtk_tree_view_real_search_enable_popdown, data);
12576 }
12577
12578 static gboolean
12579 gtk_tree_view_search_delete_event (GtkWidget *widget,
12580                                    GdkEventAny *event,
12581                                    GtkTreeView *tree_view)
12582 {
12583   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12584
12585   gtk_tree_view_search_dialog_hide (widget, tree_view);
12586
12587   return TRUE;
12588 }
12589
12590 static gboolean
12591 gtk_tree_view_search_button_press_event (GtkWidget *widget,
12592                                          GdkEventButton *event,
12593                                          GtkTreeView *tree_view)
12594 {
12595   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12596
12597   gtk_tree_view_search_dialog_hide (widget, tree_view);
12598
12599   if (event->window == tree_view->priv->bin_window)
12600     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
12601
12602   return TRUE;
12603 }
12604
12605 static gboolean
12606 gtk_tree_view_search_scroll_event (GtkWidget *widget,
12607                                    GdkEventScroll *event,
12608                                    GtkTreeView *tree_view)
12609 {
12610   gboolean retval = FALSE;
12611
12612   if (event->direction == GDK_SCROLL_UP)
12613     {
12614       gtk_tree_view_search_move (widget, tree_view, TRUE);
12615       retval = TRUE;
12616     }
12617   else if (event->direction == GDK_SCROLL_DOWN)
12618     {
12619       gtk_tree_view_search_move (widget, tree_view, FALSE);
12620       retval = TRUE;
12621     }
12622
12623   return retval;
12624 }
12625
12626 static gboolean
12627 gtk_tree_view_search_key_press_event (GtkWidget *widget,
12628                                       GdkEventKey *event,
12629                                       GtkTreeView *tree_view)
12630 {
12631   gboolean retval = FALSE;
12632
12633   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
12634   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12635
12636   /* close window and cancel the search */
12637   if (event->keyval == GDK_Escape ||
12638       event->keyval == GDK_Tab)
12639     {
12640       gtk_tree_view_search_dialog_hide (widget, tree_view);
12641       return TRUE;
12642     }
12643
12644   /* select previous matching iter */
12645   if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
12646     {
12647       gtk_tree_view_search_move (widget, tree_view, TRUE);
12648       retval = TRUE;
12649     }
12650
12651   /* select next matching iter */
12652   if (event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
12653     {
12654       gtk_tree_view_search_move (widget, tree_view, FALSE);
12655       retval = TRUE;
12656     }
12657
12658   if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK
12659       && (event->keyval == GDK_g || event->keyval == GDK_G))
12660     {
12661       gtk_tree_view_search_move (widget, tree_view, FALSE);
12662       retval = TRUE;
12663     }
12664
12665   /* renew the flush timeout */
12666   if (retval && tree_view->priv->typeselect_flush_timeout)
12667     {
12668       g_source_remove (tree_view->priv->typeselect_flush_timeout);
12669       tree_view->priv->typeselect_flush_timeout =
12670         g_timeout_add (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
12671                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
12672                        tree_view);
12673     }
12674
12675   return retval;
12676 }
12677
12678 static void
12679 gtk_tree_view_search_move (GtkWidget   *window,
12680                            GtkTreeView *tree_view,
12681                            gboolean     up)
12682 {
12683   gboolean ret;
12684   gint len;
12685   gint count = 0;
12686   const gchar *text;
12687   GtkTreeIter iter;
12688   GtkTreeModel *model;
12689   GtkTreeSelection *selection;
12690
12691   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
12692
12693   g_return_if_fail (text != NULL);
12694
12695   if (up && tree_view->priv->selected_iter == 1)
12696     return;
12697
12698   len = strlen (text);
12699
12700   if (len < 1)
12701     return;
12702
12703   model = gtk_tree_view_get_model (tree_view);
12704   selection = gtk_tree_view_get_selection (tree_view);
12705
12706   /* search */
12707   gtk_tree_selection_unselect_all (selection);
12708   if (!gtk_tree_model_get_iter_first (model, &iter))
12709     return;
12710
12711   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
12712                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
12713
12714   if (ret)
12715     {
12716       /* found */
12717       tree_view->priv->selected_iter += up?(-1):(1);
12718     }
12719   else
12720     {
12721       /* return to old iter */
12722       count = 0;
12723       gtk_tree_model_get_iter_first (model, &iter);
12724       gtk_tree_view_search_iter (model, selection,
12725                                  &iter, text,
12726                                  &count, tree_view->priv->selected_iter);
12727     }
12728 }
12729
12730 static gboolean
12731 gtk_tree_view_search_equal_func (GtkTreeModel *model,
12732                                  gint          column,
12733                                  const gchar  *key,
12734                                  GtkTreeIter  *iter,
12735                                  gpointer      search_data)
12736 {
12737   gboolean retval = TRUE;
12738   const gchar *str;
12739   gchar *normalized_string;
12740   gchar *normalized_key;
12741   gchar *case_normalized_string = NULL;
12742   gchar *case_normalized_key = NULL;
12743   GValue value = {0,};
12744   GValue transformed = {0,};
12745
12746   gtk_tree_model_get_value (model, iter, column, &value);
12747
12748   g_value_init (&transformed, G_TYPE_STRING);
12749
12750   if (!g_value_transform (&value, &transformed))
12751     {
12752       g_value_unset (&value);
12753       return TRUE;
12754     }
12755
12756   g_value_unset (&value);
12757
12758   str = g_value_get_string (&transformed);
12759   if (!str)
12760     {
12761       g_value_unset (&transformed);
12762       return TRUE;
12763     }
12764
12765   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
12766   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
12767
12768   if (normalized_string && normalized_key)
12769     {
12770       case_normalized_string = g_utf8_casefold (normalized_string, -1);
12771       case_normalized_key = g_utf8_casefold (normalized_key, -1);
12772
12773       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
12774         retval = FALSE;
12775     }
12776
12777   g_value_unset (&transformed);
12778   g_free (normalized_key);
12779   g_free (normalized_string);
12780   g_free (case_normalized_key);
12781   g_free (case_normalized_string);
12782
12783   return retval;
12784 }
12785
12786 static gboolean
12787 gtk_tree_view_search_iter (GtkTreeModel     *model,
12788                            GtkTreeSelection *selection,
12789                            GtkTreeIter      *iter,
12790                            const gchar      *text,
12791                            gint             *count,
12792                            gint              n)
12793 {
12794   GtkRBTree *tree = NULL;
12795   GtkRBNode *node = NULL;
12796   GtkTreePath *path;
12797
12798   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
12799
12800   path = gtk_tree_model_get_path (model, iter);
12801   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12802
12803   do
12804     {
12805       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
12806         {
12807           (*count)++;
12808           if (*count == n)
12809             {
12810               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
12811                                             TRUE, 0.5, 0.0);
12812               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
12813               gtk_tree_selection_select_iter (selection, iter);
12814
12815               if (path)
12816                 gtk_tree_path_free (path);
12817
12818               return TRUE;
12819             }
12820         }
12821
12822       if (node->children)
12823         {
12824           gboolean has_child;
12825           GtkTreeIter tmp;
12826
12827           tree = node->children;
12828           node = tree->root;
12829
12830           while (node->left != tree->nil)
12831             node = node->left;
12832
12833           tmp = *iter;
12834           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
12835           gtk_tree_path_down (path);
12836
12837           /* sanity check */
12838           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
12839         }
12840       else
12841         {
12842           gboolean done = FALSE;
12843
12844           do
12845             {
12846               node = _gtk_rbtree_next (tree, node);
12847
12848               if (node)
12849                 {
12850                   gboolean has_next;
12851
12852                   has_next = gtk_tree_model_iter_next (model, iter);
12853
12854                   done = TRUE;
12855                   gtk_tree_path_next (path);
12856
12857                   /* sanity check */
12858                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
12859                 }
12860               else
12861                 {
12862                   gboolean has_parent;
12863                   GtkTreeIter tmp_iter = *iter;
12864
12865                   node = tree->parent_node;
12866                   tree = tree->parent_tree;
12867
12868                   if (!tree)
12869                     {
12870                       if (path)
12871                         gtk_tree_path_free (path);
12872
12873                       /* we've run out of tree, done with this func */
12874                       return FALSE;
12875                     }
12876
12877                   has_parent = gtk_tree_model_iter_parent (model,
12878                                                            iter,
12879                                                            &tmp_iter);
12880                   gtk_tree_path_up (path);
12881
12882                   /* sanity check */
12883                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
12884                 }
12885             }
12886           while (!done);
12887         }
12888     }
12889   while (1);
12890
12891   return FALSE;
12892 }
12893
12894 static void
12895 gtk_tree_view_search_init (GtkWidget   *entry,
12896                            GtkTreeView *tree_view)
12897 {
12898   gint ret;
12899   gint len;
12900   gint count = 0;
12901   const gchar *text;
12902   GtkTreeIter iter;
12903   GtkTreeModel *model;
12904   GtkTreeSelection *selection;
12905
12906   g_return_if_fail (GTK_IS_ENTRY (entry));
12907   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12908
12909   text = gtk_entry_get_text (GTK_ENTRY (entry));
12910   len = strlen (text);
12911   model = gtk_tree_view_get_model (tree_view);
12912   selection = gtk_tree_view_get_selection (tree_view);
12913
12914   /* search */
12915   gtk_tree_selection_unselect_all (selection);
12916   if (tree_view->priv->typeselect_flush_timeout)
12917     {
12918       g_source_remove (tree_view->priv->typeselect_flush_timeout);
12919       tree_view->priv->typeselect_flush_timeout =
12920         g_timeout_add (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
12921                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
12922                        tree_view);
12923     }
12924
12925   if (len < 1)
12926     return;
12927
12928   if (!gtk_tree_model_get_iter_first (model, &iter))
12929     return;
12930
12931   ret = gtk_tree_view_search_iter (model, selection,
12932                                    &iter, text,
12933                                    &count, 1);
12934
12935   if (ret)
12936     tree_view->priv->selected_iter = 1;
12937 }
12938
12939 static void
12940 gtk_tree_view_remove_widget (GtkCellEditable *cell_editable,
12941                              GtkTreeView     *tree_view)
12942 {
12943   if (tree_view->priv->edited_column == NULL)
12944     return;
12945
12946   _gtk_tree_view_column_stop_editing (tree_view->priv->edited_column);
12947   tree_view->priv->edited_column = NULL;
12948
12949   if (GTK_WIDGET_HAS_FOCUS (cell_editable))
12950     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
12951
12952   g_signal_handlers_disconnect_by_func (cell_editable,
12953                                         gtk_tree_view_remove_widget,
12954                                         tree_view);
12955
12956   gtk_container_remove (GTK_CONTAINER (tree_view),
12957                         GTK_WIDGET (cell_editable));
12958
12959   /* FIXME should only redraw a single node */
12960   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
12961 }
12962
12963 static gboolean
12964 gtk_tree_view_start_editing (GtkTreeView *tree_view,
12965                              GtkTreePath *cursor_path)
12966 {
12967   GtkTreeIter iter;
12968   GdkRectangle background_area;
12969   GdkRectangle cell_area;
12970   GtkCellEditable *editable_widget = NULL;
12971   gchar *path_string;
12972   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
12973   gint retval = FALSE;
12974   GtkRBTree *cursor_tree;
12975   GtkRBNode *cursor_node;
12976
12977   g_assert (tree_view->priv->focus_column);
12978
12979   if (! GTK_WIDGET_REALIZED (tree_view))
12980     return FALSE;
12981
12982   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
12983       cursor_node == NULL)
12984     return FALSE;
12985
12986   path_string = gtk_tree_path_to_string (cursor_path);
12987   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
12988
12989   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
12990
12991   gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
12992                                            tree_view->priv->model,
12993                                            &iter,
12994                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
12995                                            cursor_node->children?TRUE:FALSE);
12996   gtk_tree_view_get_background_area (tree_view,
12997                                      cursor_path,
12998                                      tree_view->priv->focus_column,
12999                                      &background_area);
13000   gtk_tree_view_get_cell_area (tree_view,
13001                                cursor_path,
13002                                tree_view->priv->focus_column,
13003                                &cell_area);
13004
13005   if (gtk_tree_view_is_expander_column (tree_view, tree_view->priv->focus_column) && TREE_VIEW_DRAW_EXPANDERS (tree_view))
13006     {
13007       cell_area.x += tree_view->priv->expander_size;
13008       cell_area.width -= tree_view->priv->expander_size;
13009     }
13010
13011   if (_gtk_tree_view_column_cell_event (tree_view->priv->focus_column,
13012                                         &editable_widget,
13013                                         NULL,
13014                                         path_string,
13015                                         &background_area,
13016                                         &cell_area,
13017                                         flags))
13018     {
13019       retval = TRUE;
13020       if (editable_widget != NULL)
13021         {
13022           gint left, right;
13023           GdkRectangle area;
13024           GtkCellRenderer *cell;
13025
13026           area = cell_area;
13027           cell = _gtk_tree_view_column_get_edited_cell (tree_view->priv->focus_column);
13028           _gtk_tree_view_column_get_neighbor_sizes (tree_view->priv->focus_column, cell, &left, &right);
13029
13030           area.x += left;
13031           area.width -= right + left;
13032
13033           gtk_tree_view_real_start_editing (tree_view,
13034                                             tree_view->priv->focus_column,
13035                                             cursor_path,
13036                                             editable_widget,
13037                                             &area,
13038                                             NULL,
13039                                             flags);
13040         }
13041
13042     }
13043   g_free (path_string);
13044   return retval;
13045 }
13046
13047 static void
13048 gtk_tree_view_real_start_editing (GtkTreeView       *tree_view,
13049                                   GtkTreeViewColumn *column,
13050                                   GtkTreePath       *path,
13051                                   GtkCellEditable   *cell_editable,
13052                                   GdkRectangle      *cell_area,
13053                                   GdkEvent          *event,
13054                                   guint              flags)
13055 {
13056   gint pre_val = tree_view->priv->vadjustment->value;
13057
13058   tree_view->priv->edited_column = column;
13059   _gtk_tree_view_column_start_editing (column, GTK_CELL_EDITABLE (cell_editable));
13060
13061   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
13062
13063   cell_area->y += pre_val - tree_view->priv->vadjustment->value;
13064
13065   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
13066   gtk_tree_view_put (tree_view,
13067                      GTK_WIDGET (cell_editable),
13068                      cell_area->x, cell_area->y, cell_area->width, cell_area->height);
13069   gtk_cell_editable_start_editing (GTK_CELL_EDITABLE (cell_editable),
13070                                    (GdkEvent *)event);
13071   gtk_widget_grab_focus (GTK_WIDGET (cell_editable));
13072   g_signal_connect (cell_editable, "remove_widget",
13073                     G_CALLBACK (gtk_tree_view_remove_widget), tree_view);
13074 }
13075
13076 static void
13077 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
13078                             gboolean     cancel_editing)
13079 {
13080   GtkTreeViewColumn *column;
13081   GtkCellRenderer *cell;
13082
13083   if (tree_view->priv->edited_column == NULL)
13084     return;
13085
13086   /*
13087    * This is very evil. We need to do this, because
13088    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
13089    * later on. If gtk_tree_view_row_changed notices
13090    * tree_view->priv->edited_column != NULL, it'll call
13091    * gtk_tree_view_stop_editing again. Bad things will happen then.
13092    *
13093    * Please read that again if you intend to modify anything here.
13094    */
13095
13096   column = tree_view->priv->edited_column;
13097   tree_view->priv->edited_column = NULL;
13098
13099   cell = _gtk_tree_view_column_get_edited_cell (column);
13100   gtk_cell_renderer_stop_editing (cell, cancel_editing);
13101
13102   if (!cancel_editing)
13103     gtk_cell_editable_editing_done (column->editable_widget);
13104
13105   tree_view->priv->edited_column = column;
13106
13107   gtk_cell_editable_remove_widget (column->editable_widget);
13108 }
13109
13110
13111 /**
13112  * gtk_tree_view_set_hover_selection:
13113  * @tree_view: a #GtkTreeView
13114  * @hover: %TRUE to enable hover selection mode
13115  *
13116  * Enables of disables the hover selection mode of @tree_view.
13117  * Hover selection makes the selected row follow the pointer.
13118  * Currently, this works only for the selection modes
13119  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
13120  *
13121  * Since: 2.6
13122  **/
13123 void
13124 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
13125                                    gboolean     hover)
13126 {
13127   hover = hover != FALSE;
13128
13129   if (hover != tree_view->priv->hover_selection)
13130     {
13131       tree_view->priv->hover_selection = hover;
13132
13133       g_object_notify (G_OBJECT (tree_view), "hover-selection");
13134     }
13135 }
13136
13137 /**
13138  * gtk_tree_view_get_hover_selection:
13139  * @tree_view: a #GtkTreeView
13140  *
13141  * Returns whether hover selection mode is turned on for @tree_view.
13142  *
13143  * Return value: %TRUE if @tree_view is in hover selection mode
13144  *
13145  * Since: 2.6
13146  **/
13147 gboolean
13148 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
13149 {
13150   return tree_view->priv->hover_selection;
13151 }
13152
13153 /**
13154  * gtk_tree_view_set_hover_expand:
13155  * @tree_view: a #GtkTreeView
13156  * @expand: %TRUE to enable hover selection mode
13157  *
13158  * Enables of disables the hover expansion mode of @tree_view.
13159  * Hover expansion makes rows expand or collaps if the pointer
13160  * moves over them.
13161  *
13162  * Since: 2.6
13163  **/
13164 void
13165 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
13166                                 gboolean     expand)
13167 {
13168   expand = expand != FALSE;
13169
13170   if (expand != tree_view->priv->hover_expand)
13171     {
13172       tree_view->priv->hover_expand = expand;
13173
13174       g_object_notify (G_OBJECT (tree_view), "hover-expand");
13175     }
13176 }
13177
13178 /**
13179  * gtk_tree_view_get_hover_expand:
13180  * @tree_view: a #GtkTreeView
13181  *
13182  * Returns whether hover expansion mode is turned on for @tree_view.
13183  *
13184  * Return value: %TRUE if @tree_view is in hover expansion mode
13185  *
13186  * Since: 2.6
13187  **/
13188 gboolean
13189 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
13190 {
13191   return tree_view->priv->hover_expand;
13192 }
13193
13194 /**
13195  * gtk_tree_view_get_row_separator_func:
13196  * @tree_view: a #GtkTreeView
13197  *
13198  * Returns the current row separator function.
13199  *
13200  * Return value: the current row separator function.
13201  *
13202  * Since: 2.6
13203  **/
13204 GtkTreeViewRowSeparatorFunc
13205 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
13206 {
13207   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13208
13209   return tree_view->priv->row_separator_func;
13210 }
13211
13212 /**
13213  * gtk_tree_view_set_row_separator_func:
13214  * @tree_view: a #GtkTreeView
13215  * @func: a #GtkTreeViewRowSeparatorFunc
13216  * @data: user data to pass to @func, or %NULL
13217  * @destroy: destroy notifier for @data, or %NULL
13218  *
13219  * Sets the row separator function, which is used to determine
13220  * whether a row should be drawn as a separator. If the row separator
13221  * function is %NULL, no separators are drawn. This is the default value.
13222  *
13223  * Since: 2.6
13224  **/
13225 void
13226 gtk_tree_view_set_row_separator_func (GtkTreeView                *tree_view,
13227                                       GtkTreeViewRowSeparatorFunc func,
13228                                       gpointer                    data,
13229                                       GtkDestroyNotify            destroy)
13230 {
13231   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13232
13233   if (tree_view->priv->row_separator_destroy)
13234     (* tree_view->priv->row_separator_destroy) (tree_view->priv->row_separator_data);
13235
13236   tree_view->priv->row_separator_func = func;
13237   tree_view->priv->row_separator_data = data;
13238   tree_view->priv->row_separator_destroy = destroy;
13239 }
13240
13241
13242 static void
13243 gtk_tree_view_grab_notify (GtkWidget *widget,
13244                            gboolean   was_grabbed)
13245 {
13246   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
13247
13248   if (!was_grabbed)
13249     tree_view->priv->pressed_button = -1;
13250 }
13251
13252 static void
13253 gtk_tree_view_state_changed (GtkWidget      *widget,
13254                              GtkStateType    previous_state)
13255 {
13256   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
13257
13258   if (GTK_WIDGET_REALIZED (widget))
13259     {
13260       gdk_window_set_background (widget->window, &widget->style->base[widget->state]);
13261       gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
13262     }
13263
13264   gtk_widget_queue_draw (widget);
13265 }
13266
13267 #define __GTK_TREE_VIEW_C__
13268 #include "gtkaliasdef.c"