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