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

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