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

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