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 "gtkextendedlayout.h"
  31 #include "gtkmain.h"
  32 #include "gtkmarshalers.h"
  33 #include "gtkbuildable.h"
  34 #include "gtkbutton.h"
  35 #include "gtkalignment.h"
  36 #include "gtklabel.h"
  37 #include "gtkhbox.h"
  38 #include "gtkvbox.h"
  39 #include "gtkarrow.h"
  40 #include "gtkintl.h"
  41 #include "gtkbindings.h"
  42 #include "gtkcontainer.h"
  43 #include "gtkentry.h"
  44 #include "gtkframe.h"
  45 #include "gtktreemodelsort.h"
  46 #include "gtktooltip.h"
  47 #include "gtkprivate.h"
  48 #include "gtkalias.h"
  49
  50 #define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
  51 #define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2)
  52 #define GTK_TREE_VIEW_TIME_MS_PER_IDLE 30
  53 #define SCROLL_EDGE_SIZE 15
  54 #define EXPANDER_EXTRA_PADDING 4
  55 #define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000
  56 #define AUTO_EXPAND_TIMEOUT 500
  57
  58 /* The "background" areas of all rows/cells add up to cover the entire tree.
  59  * The background includes all inter-row and inter-cell spacing.
  60  * The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
  61  * i.e. just the cells, no spacing.
  62  */
  63
  64 #define BACKGROUND_HEIGHT(node) (GTK_RBNODE_GET_HEIGHT (node))
  65 #define CELL_HEIGHT(node, separator) ((BACKGROUND_HEIGHT (node)) - (separator))
  66
  67 /* Translate from bin_window coordinates to rbtree (tree coordinates) and
  68  * vice versa.
  69  */
  70 #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy)
  71 #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy)
  72
  73 /* This is in bin_window coordinates */
  74 #define BACKGROUND_FIRST_PIXEL(tree_view,tree,node) (RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, _gtk_rbtree_node_find_offset ((tree), (node))))
  75 #define CELL_FIRST_PIXEL(tree_view,tree,node,separator) (BACKGROUND_FIRST_PIXEL (tree_view,tree,node) + separator/2)
  76
  77 #define ROW_HEIGHT(tree_view,height) \
  78   ((height > 0) ? (height) : (tree_view)->priv->expander_size)
  79
  80
  81 typedef struct _GtkTreeViewChild GtkTreeViewChild;
  82 struct _GtkTreeViewChild
  83 {
  84   GtkWidget *widget;
  85   gint x;
  86   gint y;
  87   gint width;
  88   gint height;
  89 };
  90
  91
  92 typedef struct _TreeViewDragInfo TreeViewDragInfo;
  93 struct _TreeViewDragInfo
  94 {
  95   GdkModifierType start_button_mask;
  96   GtkTargetList *_unused_source_target_list;
  97   GdkDragAction source_actions;
  98
  99   GtkTargetList *_unused_dest_target_list;
 100
 101   guint source_set : 1;
 102   guint dest_set : 1;
 103 };
 104
 105
 106 /* Signals */
 107 enum
 108 {
 109   ROW_ACTIVATED,
 110   TEST_EXPAND_ROW,
 111   TEST_COLLAPSE_ROW,
 112   ROW_EXPANDED,
 113   ROW_COLLAPSED,
 114   COLUMNS_CHANGED,
 115   CURSOR_CHANGED,
 116   MOVE_CURSOR,
 117   SELECT_ALL,
 118   UNSELECT_ALL,
 119   SELECT_CURSOR_ROW,
 120   TOGGLE_CURSOR_ROW,
 121   EXPAND_COLLAPSE_CURSOR_ROW,
 122   SELECT_CURSOR_PARENT,
 123   START_INTERACTIVE_SEARCH,
 124   LAST_SIGNAL
 125 };
 126
 127 /* Properties */
 128 enum {
 129   PROP_0,
 130   PROP_MODEL,
 131   PROP_HADJUSTMENT,
 132   PROP_VADJUSTMENT,
 133   PROP_HEADERS_VISIBLE,
 134   PROP_HEADERS_CLICKABLE,
 135   PROP_EXPANDER_COLUMN,
 136   PROP_REORDERABLE,
 137   PROP_RULES_HINT,
 138   PROP_ENABLE_SEARCH,
 139   PROP_SEARCH_COLUMN,
 140   PROP_FIXED_HEIGHT_MODE,
 141   PROP_HOVER_SELECTION,
 142   PROP_HOVER_EXPAND,
 143   PROP_SHOW_EXPANDERS,
 144   PROP_LEVEL_INDENTATION,
 145   PROP_RUBBER_BANDING,
 146   PROP_ENABLE_GRID_LINES,
 147   PROP_ENABLE_TREE_LINES,
 148   PROP_TOOLTIP_COLUMN
 149 };
 150
 151 /* object signals */
 152 static void     gtk_tree_view_finalize             (GObject          *object);
 153 static void     gtk_tree_view_set_property         (GObject         *object,
 154                                                     guint            prop_id,
 155                                                     const GValue    *value,
 156                                                     GParamSpec      *pspec);
 157 static void     gtk_tree_view_get_property         (GObject         *object,
 158                                                     guint            prop_id,
 159                                                     GValue          *value,
 160                                                     GParamSpec      *pspec);
 161
 162 /* gtkobject signals */
 163 static void     gtk_tree_view_destroy              (GtkObject        *object);
 164
 165 /* gtkwidget signals */
 166 static void     gtk_tree_view_realize              (GtkWidget        *widget);
 167 static void     gtk_tree_view_unrealize            (GtkWidget        *widget);
 168 static void     gtk_tree_view_map                  (GtkWidget        *widget);
 169 static void     gtk_tree_view_size_request         (GtkWidget        *widget,
 170                                                     GtkRequisition   *requisition);
 171 static void     gtk_tree_view_size_allocate        (GtkWidget        *widget,
 172                                                     GtkAllocation    *allocation);
 173 static gboolean gtk_tree_view_expose               (GtkWidget        *widget,
 174                                                     GdkEventExpose   *event);
 175 static gboolean gtk_tree_view_key_press            (GtkWidget        *widget,
 176                                                     GdkEventKey      *event);
 177 static gboolean gtk_tree_view_key_release          (GtkWidget        *widget,
 178                                                     GdkEventKey      *event);
 179 static gboolean gtk_tree_view_motion               (GtkWidget        *widget,
 180                                                     GdkEventMotion   *event);
 181 static gboolean gtk_tree_view_enter_notify         (GtkWidget        *widget,
 182                                                     GdkEventCrossing *event);
 183 static gboolean gtk_tree_view_leave_notify         (GtkWidget        *widget,
 184                                                     GdkEventCrossing *event);
 185 static gboolean gtk_tree_view_button_press         (GtkWidget        *widget,
 186                                                     GdkEventButton   *event);
 187 static gboolean gtk_tree_view_button_release       (GtkWidget        *widget,
 188                                                     GdkEventButton   *event);
 189 static gboolean gtk_tree_view_grab_broken          (GtkWidget          *widget,
 190                                                     GdkEventGrabBroken *event);
 191 #if 0
 192 static gboolean gtk_tree_view_configure            (GtkWidget         *widget,
 193                                                     GdkEventConfigure *event);
 194 #endif
 195
 196 static void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 197                                                     GtkWidget        *child);
 198 static gint     gtk_tree_view_focus_out            (GtkWidget        *widget,
 199                                                     GdkEventFocus    *event);
 200 static gint     gtk_tree_view_focus                (GtkWidget        *widget,
 201                                                     GtkDirectionType  direction);
 202 static void     gtk_tree_view_grab_focus           (GtkWidget        *widget);
 203 static void     gtk_tree_view_style_set            (GtkWidget        *widget,
 204                                                     GtkStyle         *previous_style);
 205 static void     gtk_tree_view_grab_notify          (GtkWidget        *widget,
 206                                                     gboolean          was_grabbed);
 207 static void     gtk_tree_view_state_changed        (GtkWidget        *widget,
 208                                                     GtkStateType      previous_state);
 209
 210 /* container signals */
 211 static void     gtk_tree_view_remove               (GtkContainer     *container,
 212                                                     GtkWidget        *widget);
 213 static void     gtk_tree_view_forall               (GtkContainer     *container,
 214                                                     gboolean          include_internals,
 215                                                     GtkCallback       callback,
 216                                                     gpointer          callback_data);
 217
 218 /* Source side drag signals */
 219 static void gtk_tree_view_drag_begin       (GtkWidget        *widget,
 220                                             GdkDragContext   *context);
 221 static void gtk_tree_view_drag_end         (GtkWidget        *widget,
 222                                             GdkDragContext   *context);
 223 static void gtk_tree_view_drag_data_get    (GtkWidget        *widget,
 224                                             GdkDragContext   *context,
 225                                             GtkSelectionData *selection_data,
 226                                             guint             info,
 227                                             guint             time);
 228 static void gtk_tree_view_drag_data_delete (GtkWidget        *widget,
 229                                             GdkDragContext   *context);
 230
 231 /* Target side drag signals */
 232 static void     gtk_tree_view_drag_leave         (GtkWidget        *widget,
 233                                                   GdkDragContext   *context,
 234                                                   guint             time);
 235 static gboolean gtk_tree_view_drag_motion        (GtkWidget        *widget,
 236                                                   GdkDragContext   *context,
 237                                                   gint              x,
 238                                                   gint              y,
 239                                                   guint             time);
 240 static gboolean gtk_tree_view_drag_drop          (GtkWidget        *widget,
 241                                                   GdkDragContext   *context,
 242                                                   gint              x,
 243                                                   gint              y,
 244                                                   guint             time);
 245 static void     gtk_tree_view_drag_data_received (GtkWidget        *widget,
 246                                                   GdkDragContext   *context,
 247                                                   gint              x,
 248                                                   gint              y,
 249                                                   GtkSelectionData *selection_data,
 250                                                   guint             info,
 251                                                   guint             time);
 252
 253 /* tree_model signals */
 254 static void gtk_tree_view_set_adjustments                 (GtkTreeView     *tree_view,
 255                                                            GtkAdjustment   *hadj,
 256                                                            GtkAdjustment   *vadj);
 257 static gboolean gtk_tree_view_real_move_cursor            (GtkTreeView     *tree_view,
 258                                                            GtkMovementStep  step,
 259                                                            gint             count);
 260 static gboolean gtk_tree_view_real_select_all             (GtkTreeView     *tree_view);
 261 static gboolean gtk_tree_view_real_unselect_all           (GtkTreeView     *tree_view);
 262 static gboolean gtk_tree_view_real_select_cursor_row      (GtkTreeView     *tree_view,
 263                                                            gboolean         start_editing);
 264 static gboolean gtk_tree_view_real_toggle_cursor_row      (GtkTreeView     *tree_view);
 265 static gboolean gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView     *tree_view,
 266                                                                gboolean         logical,
 267                                                                gboolean         expand,
 268                                                                gboolean         open_all);
 269 static gboolean gtk_tree_view_real_select_cursor_parent   (GtkTreeView     *tree_view);
 270 static void gtk_tree_view_row_changed                     (GtkTreeModel    *model,
 271                                                            GtkTreePath     *path,
 272                                                            GtkTreeIter     *iter,
 273                                                            gpointer         data);
 274 static void gtk_tree_view_row_inserted                    (GtkTreeModel    *model,
 275                                                            GtkTreePath     *path,
 276                                                            GtkTreeIter     *iter,
 277                                                            gpointer         data);
 278 static void gtk_tree_view_row_has_child_toggled           (GtkTreeModel    *model,
 279                                                            GtkTreePath     *path,
 280                                                            GtkTreeIter     *iter,
 281                                                            gpointer         data);
 282 static void gtk_tree_view_row_deleted                     (GtkTreeModel    *model,
 283                                                            GtkTreePath     *path,
 284                                                            gpointer         data);
 285 static void gtk_tree_view_rows_reordered                  (GtkTreeModel    *model,
 286                                                            GtkTreePath     *parent,
 287                                                            GtkTreeIter     *iter,
 288                                                            gint            *new_order,
 289                                                            gpointer         data);
 290
 291 /* Incremental reflow */
 292 static gboolean validate_row             (GtkTreeView *tree_view,
 293                                           GtkRBTree   *tree,
 294                                           GtkRBNode   *node,
 295                                           GtkTreeIter *iter,
 296                                           GtkTreePath *path);
 297 static void     validate_visible_area    (GtkTreeView *tree_view);
 298 static gboolean validate_rows_handler    (GtkTreeView *tree_view);
 299 static gboolean do_validate_rows         (GtkTreeView *tree_view,
 300                                           gboolean     size_request);
 301 static gboolean validate_rows            (GtkTreeView *tree_view);
 302 static gboolean presize_handler_callback (gpointer     data);
 303 static void     install_presize_handler  (GtkTreeView *tree_view);
 304 static void     install_scroll_sync_handler (GtkTreeView *tree_view);
 305 static void     gtk_tree_view_set_top_row   (GtkTreeView *tree_view,
 306                                              GtkTreePath *path,
 307                                              gint         offset);
 308 static void     gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view);
 309 static void     gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view);
 310 static void     invalidate_empty_focus      (GtkTreeView *tree_view);
 311
 312 /* Internal functions */
 313 static gboolean gtk_tree_view_is_expander_column             (GtkTreeView        *tree_view,
 314                                                               GtkTreeViewColumn  *column);
 315 static void     gtk_tree_view_add_move_binding               (GtkBindingSet      *binding_set,
 316                                                               guint               keyval,
 317                                                               guint               modmask,
 318                                                               gboolean            add_shifted_binding,
 319                                                               GtkMovementStep     step,
 320                                                               gint                count);
 321 static gint     gtk_tree_view_unref_and_check_selection_tree (GtkTreeView        *tree_view,
 322                                                               GtkRBTree          *tree);
 323 static void     gtk_tree_view_queue_draw_path                (GtkTreeView        *tree_view,
 324                                                               GtkTreePath        *path,
 325                                                               const GdkRectangle *clip_rect);
 326 static void     gtk_tree_view_queue_draw_arrow               (GtkTreeView        *tree_view,
 327                                                               GtkRBTree          *tree,
 328                                                               GtkRBNode          *node,
 329                                                               const GdkRectangle *clip_rect);
 330 static void     gtk_tree_view_draw_arrow                     (GtkTreeView        *tree_view,
 331                                                               GtkRBTree          *tree,
 332                                                               GtkRBNode          *node,
 333                                                               gint                x,
 334                                                               gint                y);
 335 static void     gtk_tree_view_get_arrow_xrange               (GtkTreeView        *tree_view,
 336                                                               GtkRBTree          *tree,
 337                                                               gint               *x1,
 338                                                               gint               *x2);
 339 static gint     gtk_tree_view_new_column_width               (GtkTreeView        *tree_view,
 340                                                               gint                i,
 341                                                               gint               *x);
 342 static void     gtk_tree_view_adjustment_changed             (GtkAdjustment      *adjustment,
 343                                                               GtkTreeView        *tree_view);
 344 static void     gtk_tree_view_build_tree                     (GtkTreeView        *tree_view,
 345                                                               GtkRBTree          *tree,
 346                                                               GtkTreeIter        *iter,
 347                                                               gint                depth,
 348                                                               gboolean            recurse);
 349 static void     gtk_tree_view_clamp_node_visible             (GtkTreeView        *tree_view,
 350                                                               GtkRBTree          *tree,
 351                                                               GtkRBNode          *node);
 352 static void     gtk_tree_view_clamp_column_visible           (GtkTreeView        *tree_view,
 353                                                               GtkTreeViewColumn  *column,
 354                                                               gboolean            focus_to_cell);
 355 static gboolean gtk_tree_view_maybe_begin_dragging_row       (GtkTreeView        *tree_view,
 356                                                               GdkEventMotion     *event);
 357 static void     gtk_tree_view_focus_to_cursor                (GtkTreeView        *tree_view);
 358 static void     gtk_tree_view_move_cursor_up_down            (GtkTreeView        *tree_view,
 359                                                               gint                count);
 360 static void     gtk_tree_view_move_cursor_page_up_down       (GtkTreeView        *tree_view,
 361                                                               gint                count);
 362 static void     gtk_tree_view_move_cursor_left_right         (GtkTreeView        *tree_view,
 363                                                               gint                count);
 364 static void     gtk_tree_view_move_cursor_start_end          (GtkTreeView        *tree_view,
 365                                                               gint                count);
 366 static gboolean gtk_tree_view_real_collapse_row              (GtkTreeView        *tree_view,
 367                                                               GtkTreePath        *path,
 368                                                               GtkRBTree          *tree,
 369                                                               GtkRBNode          *node,
 370                                                               gboolean            animate);
 371 static gboolean gtk_tree_view_real_expand_row                (GtkTreeView        *tree_view,
 372                                                               GtkTreePath        *path,
 373                                                               GtkRBTree          *tree,
 374                                                               GtkRBNode          *node,
 375                                                               gboolean            open_all,
 376                                                               gboolean            animate);
 377 static void     gtk_tree_view_real_set_cursor                (GtkTreeView        *tree_view,
 378                                                               GtkTreePath        *path,
 379                                                               gboolean            clear_and_select,
 380                                                               gboolean            clamp_node);
 381 static gboolean gtk_tree_view_has_special_cell               (GtkTreeView        *tree_view);
 382 static void     column_sizing_notify                         (GObject            *object,
 383                                                               GParamSpec         *pspec,
 384                                                               gpointer            data);
 385 static gboolean expand_collapse_timeout                      (gpointer            data);
 386 static void     add_expand_collapse_timeout                  (GtkTreeView        *tree_view,
 387                                                               GtkRBTree          *tree,
 388                                                               GtkRBNode          *node,
 389                                                               gboolean            expand);
 390 static void     remove_expand_collapse_timeout               (GtkTreeView        *tree_view);
 391 static void     cancel_arrow_animation                       (GtkTreeView        *tree_view);
 392 static gboolean do_expand_collapse                           (GtkTreeView        *tree_view);
 393 static void     gtk_tree_view_stop_rubber_band               (GtkTreeView        *tree_view);
 394
 395 /* interactive search */
 396 static void     gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view);
 397 static void     gtk_tree_view_search_dialog_hide     (GtkWidget        *search_dialog,
 398                                                          GtkTreeView      *tree_view);
 399 static void     gtk_tree_view_search_position_func      (GtkTreeView      *tree_view,
 400                                                          GtkWidget        *search_dialog,
 401                                                          gpointer          user_data);
 402 static void     gtk_tree_view_search_disable_popdown    (GtkEntry         *entry,
 403                                                          GtkMenu          *menu,
 404                                                          gpointer          data);
 405 static void     gtk_tree_view_search_preedit_changed    (GtkIMContext     *im_context,
 406                                                          GtkTreeView      *tree_view);
 407 static void     gtk_tree_view_search_activate           (GtkEntry         *entry,
 408                                                          GtkTreeView      *tree_view);
 409 static gboolean gtk_tree_view_real_search_enable_popdown(gpointer          data);
 410 static void     gtk_tree_view_search_enable_popdown     (GtkWidget        *widget,
 411                                                          gpointer          data);
 412 static gboolean gtk_tree_view_search_delete_event       (GtkWidget        *widget,
 413                                                          GdkEventAny      *event,
 414                                                          GtkTreeView      *tree_view);
 415 static gboolean gtk_tree_view_search_button_press_event (GtkWidget        *widget,
 416                                                          GdkEventButton   *event,
 417                                                          GtkTreeView      *tree_view);
 418 static gboolean gtk_tree_view_search_scroll_event       (GtkWidget        *entry,
 419                                                          GdkEventScroll   *event,
 420                                                          GtkTreeView      *tree_view);
 421 static gboolean gtk_tree_view_search_key_press_event    (GtkWidget        *entry,
 422                                                          GdkEventKey      *event,
 423                                                          GtkTreeView      *tree_view);
 424 static gboolean gtk_tree_view_search_move               (GtkWidget        *window,
 425                                                          GtkTreeView      *tree_view,
 426                                                          gboolean          up);
 427 static gboolean gtk_tree_view_search_equal_func         (GtkTreeModel     *model,
 428                                                          gint              column,
 429                                                          const gchar      *key,
 430                                                          GtkTreeIter      *iter,
 431                                                          gpointer          search_data);
 432 static gboolean gtk_tree_view_search_iter               (GtkTreeModel     *model,
 433                                                          GtkTreeSelection *selection,
 434                                                          GtkTreeIter      *iter,
 435                                                          const gchar      *text,
 436                                                          gint             *count,
 437                                                          gint              n);
 438 static void     gtk_tree_view_search_init               (GtkWidget        *entry,
 439                                                          GtkTreeView      *tree_view);
 440 static void     gtk_tree_view_put                       (GtkTreeView      *tree_view,
 441                                                          GtkWidget        *child_widget,
 442                                                          gint              x,
 443                                                          gint              y,
 444                                                          gint              width,
 445                                                          gint              height);
 446 static gboolean gtk_tree_view_start_editing             (GtkTreeView      *tree_view,
 447                                                          GtkTreePath      *cursor_path);
 448 static void gtk_tree_view_real_start_editing (GtkTreeView       *tree_view,
 449                                               GtkTreeViewColumn *column,
 450                                               GtkTreePath       *path,
 451                                               GtkCellEditable   *cell_editable,
 452                                               GdkRectangle      *cell_area,
 453                                               GdkEvent          *event,
 454                                               guint              flags);
 455 static void gtk_tree_view_stop_editing                  (GtkTreeView *tree_view,
 456                                                          gboolean     cancel_editing);
 457 static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
 458                                                              gboolean     keybinding);
 459 static gboolean gtk_tree_view_start_interactive_search      (GtkTreeView *tree_view);
 460 static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
 461                                                          GtkTreeViewColumn *column,
 462                                                          gint               drop_position);
 463
 464 /* GtkBuildable */
 465 static void gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
 466                                                GtkBuilder  *builder,
 467                                                GObject     *child,
 468                                                const gchar *type);
 469 static void gtk_tree_view_buildable_init      (GtkBuildableIface *iface);
 470 static void gtk_tree_view_extended_layout_init (GtkExtendedLayoutIface *iface);
 471
 472 static gboolean scroll_row_timeout                   (gpointer     data);
 473 static void     add_scroll_timeout                   (GtkTreeView *tree_view);
 474 static void     remove_scroll_timeout                (GtkTreeView *tree_view);
 475
 476 static guint tree_view_signals [LAST_SIGNAL] = { 0 };
 477
 478 \f
 479
 480 /* GType Methods
 481  */
 482
 483 G_DEFINE_TYPE_WITH_CODE (GtkTreeView, gtk_tree_view, GTK_TYPE_CONTAINER,
 484                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 485                                                 gtk_tree_view_buildable_init)
 486                          G_IMPLEMENT_INTERFACE (GTK_TYPE_EXTENDED_LAYOUT,
 487                                                 gtk_tree_view_extended_layout_init))
 488
 489
 490 static void
 491 gtk_tree_view_class_init (GtkTreeViewClass *class)
 492 {
 493   GObjectClass *o_class;
 494   GtkObjectClass *object_class;
 495   GtkWidgetClass *widget_class;
 496   GtkContainerClass *container_class;
 497   GtkBindingSet *binding_set;
 498
 499   binding_set = gtk_binding_set_by_class (class);
 500
 501   o_class = (GObjectClass *) class;
 502   object_class = (GtkObjectClass *) class;
 503   widget_class = (GtkWidgetClass *) class;
 504   container_class = (GtkContainerClass *) class;
 505
 506   /* GObject signals */
 507   o_class->set_property = gtk_tree_view_set_property;
 508   o_class->get_property = gtk_tree_view_get_property;
 509   o_class->finalize = gtk_tree_view_finalize;
 510
 511   /* GtkObject signals */
 512   object_class->destroy = gtk_tree_view_destroy;
 513
 514   /* GtkWidget signals */
 515   widget_class->map = gtk_tree_view_map;
 516   widget_class->realize = gtk_tree_view_realize;
 517   widget_class->unrealize = gtk_tree_view_unrealize;
 518   widget_class->size_request = gtk_tree_view_size_request;
 519   widget_class->size_allocate = gtk_tree_view_size_allocate;
 520   widget_class->button_press_event = gtk_tree_view_button_press;
 521   widget_class->button_release_event = gtk_tree_view_button_release;
 522   widget_class->grab_broken_event = gtk_tree_view_grab_broken;
 523   /*widget_class->configure_event = gtk_tree_view_configure;*/
 524   widget_class->motion_notify_event = gtk_tree_view_motion;
 525   widget_class->expose_event = gtk_tree_view_expose;
 526   widget_class->key_press_event = gtk_tree_view_key_press;
 527   widget_class->key_release_event = gtk_tree_view_key_release;
 528   widget_class->enter_notify_event = gtk_tree_view_enter_notify;
 529   widget_class->leave_notify_event = gtk_tree_view_leave_notify;
 530   widget_class->focus_out_event = gtk_tree_view_focus_out;
 531   widget_class->drag_begin = gtk_tree_view_drag_begin;
 532   widget_class->drag_end = gtk_tree_view_drag_end;
 533   widget_class->drag_data_get = gtk_tree_view_drag_data_get;
 534   widget_class->drag_data_delete = gtk_tree_view_drag_data_delete;
 535   widget_class->drag_leave = gtk_tree_view_drag_leave;
 536   widget_class->drag_motion = gtk_tree_view_drag_motion;
 537   widget_class->drag_drop = gtk_tree_view_drag_drop;
 538   widget_class->drag_data_received = gtk_tree_view_drag_data_received;
 539   widget_class->focus = gtk_tree_view_focus;
 540   widget_class->grab_focus = gtk_tree_view_grab_focus;
 541   widget_class->style_set = gtk_tree_view_style_set;
 542   widget_class->grab_notify = gtk_tree_view_grab_notify;
 543   widget_class->state_changed = gtk_tree_view_state_changed;
 544
 545   /* GtkContainer signals */
 546   container_class->remove = gtk_tree_view_remove;
 547   container_class->forall = gtk_tree_view_forall;
 548   container_class->set_focus_child = gtk_tree_view_set_focus_child;
 549
 550   class->set_scroll_adjustments = gtk_tree_view_set_adjustments;
 551   class->move_cursor = gtk_tree_view_real_move_cursor;
 552   class->select_all = gtk_tree_view_real_select_all;
 553   class->unselect_all = gtk_tree_view_real_unselect_all;
 554   class->select_cursor_row = gtk_tree_view_real_select_cursor_row;
 555   class->toggle_cursor_row = gtk_tree_view_real_toggle_cursor_row;
 556   class->expand_collapse_cursor_row = gtk_tree_view_real_expand_collapse_cursor_row;
 557   class->select_cursor_parent = gtk_tree_view_real_select_cursor_parent;
 558   class->start_interactive_search = gtk_tree_view_start_interactive_search;
 559
 560   /* Properties */
 561
 562   g_object_class_install_property (o_class,
 563                                    PROP_MODEL,
 564                                    g_param_spec_object ("model",
 565                                                         P_("TreeView Model"),
 566                                                         P_("The model for the tree view"),
 567                                                         GTK_TYPE_TREE_MODEL,
 568                                                         GTK_PARAM_READWRITE));
 569
 570   g_object_class_install_property (o_class,
 571                                    PROP_HADJUSTMENT,
 572                                    g_param_spec_object ("hadjustment",
 573                                                         P_("Horizontal Adjustment"),
 574                                                         P_("Horizontal Adjustment for the widget"),
 575                                                         GTK_TYPE_ADJUSTMENT,
 576                                                         GTK_PARAM_READWRITE));
 577
 578   g_object_class_install_property (o_class,
 579                                    PROP_VADJUSTMENT,
 580                                    g_param_spec_object ("vadjustment",
 581                                                         P_("Vertical Adjustment"),
 582                                                         P_("Vertical Adjustment for the widget"),
 583                                                         GTK_TYPE_ADJUSTMENT,
 584                                                         GTK_PARAM_READWRITE));
 585
 586   g_object_class_install_property (o_class,
 587                                    PROP_HEADERS_VISIBLE,
 588                                    g_param_spec_boolean ("headers-visible",
 589                                                          P_("Headers Visible"),
 590                                                          P_("Show the column header buttons"),
 591                                                          TRUE,
 592                                                          GTK_PARAM_READWRITE));
 593
 594   g_object_class_install_property (o_class,
 595                                    PROP_HEADERS_CLICKABLE,
 596                                    g_param_spec_boolean ("headers-clickable",
 597                                                          P_("Headers Clickable"),
 598                                                          P_("Column headers respond to click events"),
 599                                                          TRUE,
 600                                                          GTK_PARAM_READWRITE));
 601
 602   g_object_class_install_property (o_class,
 603                                    PROP_EXPANDER_COLUMN,
 604                                    g_param_spec_object ("expander-column",
 605                                                         P_("Expander Column"),
 606                                                         P_("Set the column for the expander column"),
 607                                                         GTK_TYPE_TREE_VIEW_COLUMN,
 608                                                         GTK_PARAM_READWRITE));
 609
 610   g_object_class_install_property (o_class,
 611                                    PROP_REORDERABLE,
 612                                    g_param_spec_boolean ("reorderable",
 613                                                          P_("Reorderable"),
 614                                                          P_("View is reorderable"),
 615                                                          FALSE,
 616                                                          GTK_PARAM_READWRITE));
 617
 618   g_object_class_install_property (o_class,
 619                                    PROP_RULES_HINT,
 620                                    g_param_spec_boolean ("rules-hint",
 621                                                          P_("Rules Hint"),
 622                                                          P_("Set a hint to the theme engine to draw rows in alternating colors"),
 623                                                          FALSE,
 624                                                          GTK_PARAM_READWRITE));
 625
 626     g_object_class_install_property (o_class,
 627                                      PROP_ENABLE_SEARCH,
 628                                      g_param_spec_boolean ("enable-search",
 629                                                            P_("Enable Search"),
 630                                                            P_("View allows user to search through columns interactively"),
 631                                                            TRUE,
 632                                                            GTK_PARAM_READWRITE));
 633
 634     g_object_class_install_property (o_class,
 635                                      PROP_SEARCH_COLUMN,
 636                                      g_param_spec_int ("search-column",
 637                                                        P_("Search Column"),
 638                                                        P_("Model column to search through during interactive search"),
 639                                                        -1,
 640                                                        G_MAXINT,
 641                                                        -1,
 642                                                        GTK_PARAM_READWRITE));
 643
 644     /**
 645      * GtkTreeView:fixed-height-mode:
 646      *
 647      * Setting the ::fixed-height-mode property to %TRUE speeds up
 648      * #GtkTreeView by assuming that all rows have the same height.
 649      * Only enable this option if all rows are the same height.
 650      * Please see gtk_tree_view_set_fixed_height_mode() for more
 651      * information on this option.
 652      *
 653      * Since: 2.4
 654      **/
 655     g_object_class_install_property (o_class,
 656                                      PROP_FIXED_HEIGHT_MODE,
 657                                      g_param_spec_boolean ("fixed-height-mode",
 658                                                            P_("Fixed Height Mode"),
 659                                                            P_("Speeds up GtkTreeView by assuming that all rows have the same height"),
 660                                                            FALSE,
 661                                                            GTK_PARAM_READWRITE));
 662
 663     /**
 664      * GtkTreeView:hover-selection:
 665      *
 666      * Enables of disables the hover selection mode of @tree_view.
 667      * Hover selection makes the selected row follow the pointer.
 668      * Currently, this works only for the selection modes
 669      * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
 670      *
 671      * This mode is primarily intended for treeviews in popups, e.g.
 672      * in #GtkComboBox or #GtkEntryCompletion.
 673      *
 674      * Since: 2.6
 675      */
 676     g_object_class_install_property (o_class,
 677                                      PROP_HOVER_SELECTION,
 678                                      g_param_spec_boolean ("hover-selection",
 679                                                            P_("Hover Selection"),
 680                                                            P_("Whether the selection should follow the pointer"),
 681                                                            FALSE,
 682                                                            GTK_PARAM_READWRITE));
 683
 684     /**
 685      * GtkTreeView:hover-expand:
 686      *
 687      * Enables of disables the hover expansion mode of @tree_view.
 688      * Hover expansion makes rows expand or collapse if the pointer moves
 689      * over them.
 690      *
 691      * This mode is primarily intended for treeviews in popups, e.g.
 692      * in #GtkComboBox or #GtkEntryCompletion.
 693      *
 694      * Since: 2.6
 695      */
 696     g_object_class_install_property (o_class,
 697                                      PROP_HOVER_EXPAND,
 698                                      g_param_spec_boolean ("hover-expand",
 699                                                            P_("Hover Expand"),
 700                                                            P_("Whether rows should be expanded/collapsed when the pointer moves over them"),
 701                                                            FALSE,
 702                                                            GTK_PARAM_READWRITE));
 703
 704     /**
 705      * GtkTreeView:show-expanders:
 706      *
 707      * %TRUE if the view has expanders.
 708      *
 709      * Since: 2.12
 710      */
 711     g_object_class_install_property (o_class,
 712                                      PROP_SHOW_EXPANDERS,
 713                                      g_param_spec_boolean ("show-expanders",
 714                                                            P_("Show Expanders"),
 715                                                            P_("View has expanders"),
 716                                                            TRUE,
 717                                                            GTK_PARAM_READWRITE));
 718
 719     /**
 720      * GtkTreeView:level-indentation:
 721      *
 722      * Extra indentation for each level.
 723      *
 724      * Since: 2.12
 725      */
 726     g_object_class_install_property (o_class,
 727                                      PROP_LEVEL_INDENTATION,
 728                                      g_param_spec_int ("level-indentation",
 729                                                        P_("Level Indentation"),
 730                                                        P_("Extra indentation for each level"),
 731                                                        0,
 732                                                        G_MAXINT,
 733                                                        0,
 734                                                        GTK_PARAM_READWRITE));
 735
 736     g_object_class_install_property (o_class,
 737                                      PROP_RUBBER_BANDING,
 738                                      g_param_spec_boolean ("rubber-banding",
 739                                                            P_("Rubber Banding"),
 740                                                            P_("Whether to enable selection of multiple items by dragging the mouse pointer"),
 741                                                            FALSE,
 742                                                            GTK_PARAM_READWRITE));
 743
 744     g_object_class_install_property (o_class,
 745                                      PROP_ENABLE_GRID_LINES,
 746                                      g_param_spec_enum ("enable-grid-lines",
 747                                                         P_("Enable Grid Lines"),
 748                                                         P_("Whether grid lines should be drawn in the tree view"),
 749                                                         GTK_TYPE_TREE_VIEW_GRID_LINES,
 750                                                         GTK_TREE_VIEW_GRID_LINES_NONE,
 751                                                         GTK_PARAM_READWRITE));
 752
 753     g_object_class_install_property (o_class,
 754                                      PROP_ENABLE_TREE_LINES,
 755                                      g_param_spec_boolean ("enable-tree-lines",
 756                                                            P_("Enable Tree Lines"),
 757                                                            P_("Whether tree lines should be drawn in the tree view"),
 758                                                            FALSE,
 759                                                            GTK_PARAM_READWRITE));
 760
 761     g_object_class_install_property (o_class,
 762                                      PROP_TOOLTIP_COLUMN,
 763                                      g_param_spec_int ("tooltip-column",
 764                                                        P_("Tooltip Column"),
 765                                                        P_("The column in the model containing the tooltip texts for the rows"),
 766                                                        -1,
 767                                                        G_MAXINT,
 768                                                        -1,
 769                                                        GTK_PARAM_READWRITE));
 770
 771   /* Style properties */
 772 #define _TREE_VIEW_EXPANDER_SIZE 12
 773 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
 774 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
 775
 776   gtk_widget_class_install_style_property (widget_class,
 777                                            g_param_spec_int ("expander-size",
 778                                                              P_("Expander Size"),
 779                                                              P_("Size of the expander arrow"),
 780                                                              0,
 781                                                              G_MAXINT,
 782                                                              _TREE_VIEW_EXPANDER_SIZE,
 783                                                              GTK_PARAM_READABLE));
 784
 785   gtk_widget_class_install_style_property (widget_class,
 786                                            g_param_spec_int ("vertical-separator",
 787                                                              P_("Vertical Separator Width"),
 788                                                              P_("Vertical space between cells.  Must be an even number"),
 789                                                              0,
 790                                                              G_MAXINT,
 791                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
 792                                                              GTK_PARAM_READABLE));
 793
 794   gtk_widget_class_install_style_property (widget_class,
 795                                            g_param_spec_int ("horizontal-separator",
 796                                                              P_("Horizontal Separator Width"),
 797                                                              P_("Horizontal space between cells.  Must be an even number"),
 798                                                              0,
 799                                                              G_MAXINT,
 800                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
 801                                                              GTK_PARAM_READABLE));
 802
 803   gtk_widget_class_install_style_property (widget_class,
 804                                            g_param_spec_boolean ("allow-rules",
 805                                                                  P_("Allow Rules"),
 806                                                                  P_("Allow drawing of alternating color rows"),
 807                                                                  TRUE,
 808                                                                  GTK_PARAM_READABLE));
 809
 810   gtk_widget_class_install_style_property (widget_class,
 811                                            g_param_spec_boolean ("indent-expanders",
 812                                                                  P_("Indent Expanders"),
 813                                                                  P_("Make the expanders indented"),
 814                                                                  TRUE,
 815                                                                  GTK_PARAM_READABLE));
 816
 817   gtk_widget_class_install_style_property (widget_class,
 818                                            g_param_spec_boxed ("even-row-color",
 819                                                                P_("Even Row Color"),
 820                                                                P_("Color to use for even rows"),
 821                                                                GDK_TYPE_COLOR,
 822                                                                GTK_PARAM_READABLE));
 823
 824   gtk_widget_class_install_style_property (widget_class,
 825                                            g_param_spec_boxed ("odd-row-color",
 826                                                                P_("Odd Row Color"),
 827                                                                P_("Color to use for odd rows"),
 828                                                                GDK_TYPE_COLOR,
 829                                                                GTK_PARAM_READABLE));
 830
 831   gtk_widget_class_install_style_property (widget_class,
 832                                            g_param_spec_boolean ("row-ending-details",
 833                                                                  P_("Row Ending details"),
 834                                                                  P_("Enable extended row background theming"),
 835                                                                  FALSE,
 836                                                                  GTK_PARAM_READABLE));
 837
 838   gtk_widget_class_install_style_property (widget_class,
 839                                            g_param_spec_int ("grid-line-width",
 840                                                              P_("Grid line width"),
 841                                                              P_("Width, in pixels, of the tree view grid lines"),
 842                                                              0, G_MAXINT, 1,
 843                                                              GTK_PARAM_READABLE));
 844
 845   gtk_widget_class_install_style_property (widget_class,
 846                                            g_param_spec_int ("tree-line-width",
 847                                                              P_("Tree line width"),
 848                                                              P_("Width, in pixels, of the tree view lines"),
 849                                                              0, G_MAXINT, 1,
 850                                                              GTK_PARAM_READABLE));
 851
 852   gtk_widget_class_install_style_property (widget_class,
 853                                            g_param_spec_string ("grid-line-pattern",
 854                                                                 P_("Grid line pattern"),
 855                                                                 P_("Dash pattern used to draw the tree view grid lines"),
 856                                                                 "\1\1",
 857                                                                 GTK_PARAM_READABLE));
 858
 859   gtk_widget_class_install_style_property (widget_class,
 860                                            g_param_spec_string ("tree-line-pattern",
 861                                                                 P_("Tree line pattern"),
 862                                                                 P_("Dash pattern used to draw the tree view lines"),
 863                                                                 "\1\1",
 864                                                                 GTK_PARAM_READABLE));
 865
 866   /* Signals */
 867   /**
 868    * GtkTreeView::set-scroll-adjustments
 869    * @horizontal: the horizontal #GtkAdjustment
 870    * @vertical: the vertical #GtkAdjustment
 871    *
 872    * Set the scroll adjustments for the tree view. Usually scrolled containers
 873    * like #GtkScrolledWindow will emit this signal to connect two instances
 874    * of #GtkScrollbar to the scroll directions of the #GtkTreeView.
 875    */
 876   widget_class->set_scroll_adjustments_signal =
 877     g_signal_new (I_("set-scroll-adjustments"),
 878                   G_TYPE_FROM_CLASS (o_class),
 879                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 880                   G_STRUCT_OFFSET (GtkTreeViewClass, set_scroll_adjustments),
 881                   NULL, NULL,
 882                   _gtk_marshal_VOID__OBJECT_OBJECT,
 883                   G_TYPE_NONE, 2,
 884                   GTK_TYPE_ADJUSTMENT,
 885                   GTK_TYPE_ADJUSTMENT);
 886
 887   /**
 888    * GtkTreeView::row-activated:
 889    * @tree_view: the object on which the signal is emitted
 890    * @path: the #GtkTreePath for the activated row
 891    * @column: the #GtkTreeViewColumn in which the activation occurred
 892    *
 893    * The "row-activated" signal is emitted when the method
 894    * gtk_tree_view_row_activated() is called or the user double clicks
 895    * a treeview row. It is also emitted when a non-editable row is
 896    * selected and one of the keys: Space, Shift+Space, Return or
 897    * Enter is pressed.
 898    *
 899    * For selection handling refer to the <link linkend="TreeWidget">tree
 900    * widget conceptual overview</link> as well as #GtkTreeSelection.
 901    */
 902   tree_view_signals[ROW_ACTIVATED] =
 903     g_signal_new (I_("row-activated"),
 904                   G_TYPE_FROM_CLASS (o_class),
 905                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 906                   G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
 907                   NULL, NULL,
 908                   _gtk_marshal_VOID__BOXED_OBJECT,
 909                   G_TYPE_NONE, 2,
 910                   GTK_TYPE_TREE_PATH,
 911                   GTK_TYPE_TREE_VIEW_COLUMN);
 912
 913   /**
 914    * GtkTreeView::test-expand-row:
 915    * @tree_view: the object on which the signal is emitted
 916    * @iter: the tree iter of the row to expand
 917    * @path: a tree path that points to the row
 918    *
 919    * The given row is about to be expanded (show its children nodes). Use this
 920    * signal if you need to control the expandability of individual rows.
 921    *
 922    * Returns: %FALSE to allow expansion, %TRUE to reject
 923    */
 924   tree_view_signals[TEST_EXPAND_ROW] =
 925     g_signal_new (I_("test-expand-row"),
 926                   G_TYPE_FROM_CLASS (o_class),
 927                   G_SIGNAL_RUN_LAST,
 928                   G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
 929                   _gtk_boolean_handled_accumulator, NULL,
 930                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
 931                   G_TYPE_BOOLEAN, 2,
 932                   GTK_TYPE_TREE_ITER,
 933                   GTK_TYPE_TREE_PATH);
 934
 935   /**
 936    * GtkTreeView::test-collapse-row:
 937    * @tree_view: the object on which the signal is emitted
 938    * @iter: the tree iter of the row to collapse
 939    * @path: a tree path that points to the row
 940    *
 941    * The given row is about to be collapsed (hide its children nodes). Use this
 942    * signal if you need to control the collapsibility of individual rows.
 943    *
 944    * Returns: %FALSE to allow collapsing, %TRUE to reject
 945    */
 946   tree_view_signals[TEST_COLLAPSE_ROW] =
 947     g_signal_new (I_("test-collapse-row"),
 948                   G_TYPE_FROM_CLASS (o_class),
 949                   G_SIGNAL_RUN_LAST,
 950                   G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
 951                   _gtk_boolean_handled_accumulator, NULL,
 952                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
 953                   G_TYPE_BOOLEAN, 2,
 954                   GTK_TYPE_TREE_ITER,
 955                   GTK_TYPE_TREE_PATH);
 956
 957   /**
 958    * GtkTreeView::row-expanded:
 959    * @tree_view: the object on which the signal is emitted
 960    * @iter: the tree iter of the expanded row
 961    * @path: a tree path that points to the row
 962    *
 963    * The given row has been expanded (child nodes are shown).
 964    */
 965   tree_view_signals[ROW_EXPANDED] =
 966     g_signal_new (I_("row-expanded"),
 967                   G_TYPE_FROM_CLASS (o_class),
 968                   G_SIGNAL_RUN_LAST,
 969                   G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
 970                   NULL, NULL,
 971                   _gtk_marshal_VOID__BOXED_BOXED,
 972                   G_TYPE_NONE, 2,
 973                   GTK_TYPE_TREE_ITER,
 974                   GTK_TYPE_TREE_PATH);
 975
 976   /**
 977    * GtkTreeView::row-collapsed:
 978    * @tree_view: the object on which the signal is emitted
 979    * @iter: the tree iter of the collapsed row
 980    * @path: a tree path that points to the row
 981    *
 982    * The given row has been collapsed (child nodes are hidden).
 983    */
 984   tree_view_signals[ROW_COLLAPSED] =
 985     g_signal_new (I_("row-collapsed"),
 986                   G_TYPE_FROM_CLASS (o_class),
 987                   G_SIGNAL_RUN_LAST,
 988                   G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
 989                   NULL, NULL,
 990                   _gtk_marshal_VOID__BOXED_BOXED,
 991                   G_TYPE_NONE, 2,
 992                   GTK_TYPE_TREE_ITER,
 993                   GTK_TYPE_TREE_PATH);
 994
 995   /**
 996    * GtkTreeView::columns-changed:
 997    * @tree_view: the object on which the signal is emitted
 998    *
 999    * The number of columns of the treeview has changed.
1000    */
1001   tree_view_signals[COLUMNS_CHANGED] =
1002     g_signal_new (I_("columns-changed"),
1003                   G_TYPE_FROM_CLASS (o_class),
1004                   G_SIGNAL_RUN_LAST,
1005                   G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
1006                   NULL, NULL,
1007                   _gtk_marshal_VOID__VOID,
1008                   G_TYPE_NONE, 0);
1009
1010   /**
1011    * GtkTreeView::cursor-changed:
1012    * @tree_view: the object on which the signal is emitted
1013    *
1014    * The position of the cursor (focused cell) has changed.
1015    */
1016   tree_view_signals[CURSOR_CHANGED] =
1017     g_signal_new (I_("cursor-changed"),
1018                   G_TYPE_FROM_CLASS (o_class),
1019                   G_SIGNAL_RUN_LAST,
1020                   G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
1021                   NULL, NULL,
1022                   _gtk_marshal_VOID__VOID,
1023                   G_TYPE_NONE, 0);
1024
1025   tree_view_signals[MOVE_CURSOR] =
1026     g_signal_new (I_("move-cursor"),
1027                   G_TYPE_FROM_CLASS (object_class),
1028                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1029                   G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
1030                   NULL, NULL,
1031                   _gtk_marshal_BOOLEAN__ENUM_INT,
1032                   G_TYPE_BOOLEAN, 2,
1033                   GTK_TYPE_MOVEMENT_STEP,
1034                   G_TYPE_INT);
1035
1036   tree_view_signals[SELECT_ALL] =
1037     g_signal_new (I_("select-all"),
1038                   G_TYPE_FROM_CLASS (object_class),
1039                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1040                   G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
1041                   NULL, NULL,
1042                   _gtk_marshal_BOOLEAN__VOID,
1043                   G_TYPE_BOOLEAN, 0);
1044
1045   tree_view_signals[UNSELECT_ALL] =
1046     g_signal_new (I_("unselect-all"),
1047                   G_TYPE_FROM_CLASS (object_class),
1048                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1049                   G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
1050                   NULL, NULL,
1051                   _gtk_marshal_BOOLEAN__VOID,
1052                   G_TYPE_BOOLEAN, 0);
1053
1054   tree_view_signals[SELECT_CURSOR_ROW] =
1055     g_signal_new (I_("select-cursor-row"),
1056                   G_TYPE_FROM_CLASS (object_class),
1057                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1058                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
1059                   NULL, NULL,
1060                   _gtk_marshal_BOOLEAN__BOOLEAN,
1061                   G_TYPE_BOOLEAN, 1,
1062                   G_TYPE_BOOLEAN);
1063
1064   tree_view_signals[TOGGLE_CURSOR_ROW] =
1065     g_signal_new (I_("toggle-cursor-row"),
1066                   G_TYPE_FROM_CLASS (object_class),
1067                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1068                   G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
1069                   NULL, NULL,
1070                   _gtk_marshal_BOOLEAN__VOID,
1071                   G_TYPE_BOOLEAN, 0);
1072
1073   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
1074     g_signal_new (I_("expand-collapse-cursor-row"),
1075                   G_TYPE_FROM_CLASS (object_class),
1076                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1077                   G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
1078                   NULL, NULL,
1079                   _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
1080                   G_TYPE_BOOLEAN, 3,
1081                   G_TYPE_BOOLEAN,
1082                   G_TYPE_BOOLEAN,
1083                   G_TYPE_BOOLEAN);
1084
1085   tree_view_signals[SELECT_CURSOR_PARENT] =
1086     g_signal_new (I_("select-cursor-parent"),
1087                   G_TYPE_FROM_CLASS (object_class),
1088                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1089                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
1090                   NULL, NULL,
1091                   _gtk_marshal_BOOLEAN__VOID,
1092                   G_TYPE_BOOLEAN, 0);
1093
1094   tree_view_signals[START_INTERACTIVE_SEARCH] =
1095     g_signal_new (I_("start-interactive-search"),
1096                   G_TYPE_FROM_CLASS (object_class),
1097                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1098                   G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
1099                   NULL, NULL,
1100                   _gtk_marshal_BOOLEAN__VOID,
1101                   G_TYPE_BOOLEAN, 0);
1102
1103   /* Key bindings */
1104   gtk_tree_view_add_move_binding (binding_set, GDK_Up, 0, TRUE,
1105                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1106   gtk_tree_view_add_move_binding (binding_set, GDK_KP_Up, 0, TRUE,
1107                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1108
1109   gtk_tree_view_add_move_binding (binding_set, GDK_Down, 0, TRUE,
1110                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1111   gtk_tree_view_add_move_binding (binding_set, GDK_KP_Down, 0, TRUE,
1112                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1113
1114   gtk_tree_view_add_move_binding (binding_set, GDK_p, GDK_CONTROL_MASK, FALSE,
1115                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1116
1117   gtk_tree_view_add_move_binding (binding_set, GDK_n, GDK_CONTROL_MASK, FALSE,
1118                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1119
1120   gtk_tree_view_add_move_binding (binding_set, GDK_Home, 0, TRUE,
1121                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1122   gtk_tree_view_add_move_binding (binding_set, GDK_KP_Home, 0, TRUE,
1123                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1124
1125   gtk_tree_view_add_move_binding (binding_set, GDK_End, 0, TRUE,
1126                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1127   gtk_tree_view_add_move_binding (binding_set, GDK_KP_End, 0, TRUE,
1128                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1129
1130   gtk_tree_view_add_move_binding (binding_set, GDK_Page_Up, 0, TRUE,
1131                                   GTK_MOVEMENT_PAGES, -1);
1132   gtk_tree_view_add_move_binding (binding_set, GDK_KP_Page_Up, 0, TRUE,
1133                                   GTK_MOVEMENT_PAGES, -1);
1134
1135   gtk_tree_view_add_move_binding (binding_set, GDK_Page_Down, 0, TRUE,
1136                                   GTK_MOVEMENT_PAGES, 1);
1137   gtk_tree_view_add_move_binding (binding_set, GDK_KP_Page_Down, 0, TRUE,
1138                                   GTK_MOVEMENT_PAGES, 1);
1139
1140
1141   gtk_binding_entry_add_signal (binding_set, GDK_Right, 0, "move-cursor", 2,
1142                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1143                                 G_TYPE_INT, 1);
1144
1145   gtk_binding_entry_add_signal (binding_set, GDK_Left, 0, "move-cursor", 2,
1146                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1147                                 G_TYPE_INT, -1);
1148
1149   gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, 0, "move-cursor", 2,
1150                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1151                                 G_TYPE_INT, 1);
1152
1153   gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, 0, "move-cursor", 2,
1154                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1155                                 G_TYPE_INT, -1);
1156
1157   gtk_binding_entry_add_signal (binding_set, GDK_Right, GDK_CONTROL_MASK,
1158                                 "move-cursor", 2,
1159                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1160                                 G_TYPE_INT, 1);
1161
1162   gtk_binding_entry_add_signal (binding_set, GDK_Left, GDK_CONTROL_MASK,
1163                                 "move-cursor", 2,
1164                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1165                                 G_TYPE_INT, -1);
1166
1167   gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, GDK_CONTROL_MASK,
1168                                 "move-cursor", 2,
1169                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1170                                 G_TYPE_INT, 1);
1171
1172   gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, GDK_CONTROL_MASK,
1173                                 "move-cursor", 2,
1174                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1175                                 G_TYPE_INT, -1);
1176
1177   gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1178   gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1179
1180   gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK, "select-all", 0);
1181   gtk_binding_entry_add_signal (binding_set, GDK_slash, GDK_CONTROL_MASK, "select-all", 0);
1182
1183   gtk_binding_entry_add_signal (binding_set, GDK_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1184   gtk_binding_entry_add_signal (binding_set, GDK_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1185
1186   gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1187                                 G_TYPE_BOOLEAN, TRUE);
1188   gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1189                                 G_TYPE_BOOLEAN, TRUE);
1190
1191   gtk_binding_entry_add_signal (binding_set, GDK_space, 0, "select-cursor-row", 1,
1192                                 G_TYPE_BOOLEAN, TRUE);
1193   gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, 0, "select-cursor-row", 1,
1194                                 G_TYPE_BOOLEAN, TRUE);
1195   gtk_binding_entry_add_signal (binding_set, GDK_Return, 0, "select-cursor-row", 1,
1196                                 G_TYPE_BOOLEAN, TRUE);
1197   gtk_binding_entry_add_signal (binding_set, GDK_ISO_Enter, 0, "select-cursor-row", 1,
1198                                 G_TYPE_BOOLEAN, TRUE);
1199   gtk_binding_entry_add_signal (binding_set, GDK_KP_Enter, 0, "select-cursor-row", 1,
1200                                 G_TYPE_BOOLEAN, TRUE);
1201
1202   /* expand and collapse rows */
1203   gtk_binding_entry_add_signal (binding_set, GDK_plus, 0, "expand-collapse-cursor-row", 3,
1204                                 G_TYPE_BOOLEAN, TRUE,
1205                                 G_TYPE_BOOLEAN, TRUE,
1206                                 G_TYPE_BOOLEAN, FALSE);
1207
1208   gtk_binding_entry_add_signal (binding_set, GDK_asterisk, 0,
1209                                 "expand-collapse-cursor-row", 3,
1210                                 G_TYPE_BOOLEAN, TRUE,
1211                                 G_TYPE_BOOLEAN, TRUE,
1212                                 G_TYPE_BOOLEAN, TRUE);
1213   gtk_binding_entry_add_signal (binding_set, GDK_KP_Multiply, 0,
1214                                 "expand-collapse-cursor-row", 3,
1215                                 G_TYPE_BOOLEAN, TRUE,
1216                                 G_TYPE_BOOLEAN, TRUE,
1217                                 G_TYPE_BOOLEAN, TRUE);
1218
1219   gtk_binding_entry_add_signal (binding_set, GDK_slash, 0,
1220                                 "expand-collapse-cursor-row", 3,
1221                                 G_TYPE_BOOLEAN, TRUE,
1222                                 G_TYPE_BOOLEAN, FALSE,
1223                                 G_TYPE_BOOLEAN, FALSE);
1224   gtk_binding_entry_add_signal (binding_set, GDK_KP_Divide, 0,
1225                                 "expand-collapse-cursor-row", 3,
1226                                 G_TYPE_BOOLEAN, TRUE,
1227                                 G_TYPE_BOOLEAN, FALSE,
1228                                 G_TYPE_BOOLEAN, FALSE);
1229
1230   /* Not doable on US keyboards */
1231   gtk_binding_entry_add_signal (binding_set, GDK_plus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1232                                 G_TYPE_BOOLEAN, TRUE,
1233                                 G_TYPE_BOOLEAN, TRUE,
1234                                 G_TYPE_BOOLEAN, TRUE);
1235   gtk_binding_entry_add_signal (binding_set, GDK_KP_Add, 0, "expand-collapse-cursor-row", 3,
1236                                 G_TYPE_BOOLEAN, TRUE,
1237                                 G_TYPE_BOOLEAN, TRUE,
1238                                 G_TYPE_BOOLEAN, FALSE);
1239   gtk_binding_entry_add_signal (binding_set, GDK_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1240                                 G_TYPE_BOOLEAN, TRUE,
1241                                 G_TYPE_BOOLEAN, TRUE,
1242                                 G_TYPE_BOOLEAN, TRUE);
1243   gtk_binding_entry_add_signal (binding_set, GDK_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1244                                 G_TYPE_BOOLEAN, TRUE,
1245                                 G_TYPE_BOOLEAN, TRUE,
1246                                 G_TYPE_BOOLEAN, TRUE);
1247   gtk_binding_entry_add_signal (binding_set, GDK_Right, GDK_SHIFT_MASK,
1248                                 "expand-collapse-cursor-row", 3,
1249                                 G_TYPE_BOOLEAN, FALSE,
1250                                 G_TYPE_BOOLEAN, TRUE,
1251                                 G_TYPE_BOOLEAN, TRUE);
1252   gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, GDK_SHIFT_MASK,
1253                                 "expand-collapse-cursor-row", 3,
1254                                 G_TYPE_BOOLEAN, FALSE,
1255                                 G_TYPE_BOOLEAN, TRUE,
1256                                 G_TYPE_BOOLEAN, TRUE);
1257   gtk_binding_entry_add_signal (binding_set, GDK_Right,
1258                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1259                                 "expand-collapse-cursor-row", 3,
1260                                 G_TYPE_BOOLEAN, FALSE,
1261                                 G_TYPE_BOOLEAN, TRUE,
1262                                 G_TYPE_BOOLEAN, TRUE);
1263   gtk_binding_entry_add_signal (binding_set, GDK_KP_Right,
1264                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1265                                 "expand-collapse-cursor-row", 3,
1266                                 G_TYPE_BOOLEAN, FALSE,
1267                                 G_TYPE_BOOLEAN, TRUE,
1268                                 G_TYPE_BOOLEAN, TRUE);
1269
1270   gtk_binding_entry_add_signal (binding_set, GDK_minus, 0, "expand-collapse-cursor-row", 3,
1271                                 G_TYPE_BOOLEAN, TRUE,
1272                                 G_TYPE_BOOLEAN, FALSE,
1273                                 G_TYPE_BOOLEAN, FALSE);
1274   gtk_binding_entry_add_signal (binding_set, GDK_minus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1275                                 G_TYPE_BOOLEAN, TRUE,
1276                                 G_TYPE_BOOLEAN, FALSE,
1277                                 G_TYPE_BOOLEAN, TRUE);
1278   gtk_binding_entry_add_signal (binding_set, GDK_KP_Subtract, 0, "expand-collapse-cursor-row", 3,
1279                                 G_TYPE_BOOLEAN, TRUE,
1280                                 G_TYPE_BOOLEAN, FALSE,
1281                                 G_TYPE_BOOLEAN, FALSE);
1282   gtk_binding_entry_add_signal (binding_set, GDK_KP_Subtract, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1283                                 G_TYPE_BOOLEAN, TRUE,
1284                                 G_TYPE_BOOLEAN, FALSE,
1285                                 G_TYPE_BOOLEAN, TRUE);
1286   gtk_binding_entry_add_signal (binding_set, GDK_Left, GDK_SHIFT_MASK,
1287                                 "expand-collapse-cursor-row", 3,
1288                                 G_TYPE_BOOLEAN, FALSE,
1289                                 G_TYPE_BOOLEAN, FALSE,
1290                                 G_TYPE_BOOLEAN, TRUE);
1291   gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, GDK_SHIFT_MASK,
1292                                 "expand-collapse-cursor-row", 3,
1293                                 G_TYPE_BOOLEAN, FALSE,
1294                                 G_TYPE_BOOLEAN, FALSE,
1295                                 G_TYPE_BOOLEAN, TRUE);
1296   gtk_binding_entry_add_signal (binding_set, GDK_Left,
1297                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1298                                 "expand-collapse-cursor-row", 3,
1299                                 G_TYPE_BOOLEAN, FALSE,
1300                                 G_TYPE_BOOLEAN, FALSE,
1301                                 G_TYPE_BOOLEAN, TRUE);
1302   gtk_binding_entry_add_signal (binding_set, GDK_KP_Left,
1303                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1304                                 "expand-collapse-cursor-row", 3,
1305                                 G_TYPE_BOOLEAN, FALSE,
1306                                 G_TYPE_BOOLEAN, FALSE,
1307                                 G_TYPE_BOOLEAN, TRUE);
1308
1309   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0, "select-cursor-parent", 0);
1310   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1311
1312   gtk_binding_entry_add_signal (binding_set, GDK_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1313
1314   gtk_binding_entry_add_signal (binding_set, GDK_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1315
1316   g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
1317 }
1318
1319 static void
1320 gtk_tree_view_buildable_init (GtkBuildableIface *iface)
1321 {
1322   iface->add_child = gtk_tree_view_buildable_add_child;
1323 }
1324
1325 static void
1326 gtk_tree_view_init (GtkTreeView *tree_view)
1327 {
1328   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
1329
1330   GTK_WIDGET_SET_FLAGS (tree_view, GTK_CAN_FOCUS);
1331
1332   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1333
1334   tree_view->priv->flags =  GTK_TREE_VIEW_SHOW_EXPANDERS
1335                             | GTK_TREE_VIEW_DRAW_KEYFOCUS
1336                             | GTK_TREE_VIEW_HEADERS_VISIBLE;
1337
1338   /* We need some padding */
1339   tree_view->priv->dy = 0;
1340   tree_view->priv->cursor_offset = 0;
1341   tree_view->priv->n_columns = 0;
1342   tree_view->priv->header_height = 1;
1343   tree_view->priv->x_drag = 0;
1344   tree_view->priv->drag_pos = -1;
1345   tree_view->priv->header_has_focus = FALSE;
1346   tree_view->priv->pressed_button = -1;
1347   tree_view->priv->press_start_x = -1;
1348   tree_view->priv->press_start_y = -1;
1349   tree_view->priv->reorderable = FALSE;
1350   tree_view->priv->presize_handler_timer = 0;
1351   tree_view->priv->scroll_sync_timer = 0;
1352   tree_view->priv->fixed_height = -1;
1353   tree_view->priv->fixed_height_mode = FALSE;
1354   tree_view->priv->fixed_height_check = 0;
1355   gtk_tree_view_set_adjustments (tree_view, NULL, NULL);
1356   tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
1357   tree_view->priv->enable_search = TRUE;
1358   tree_view->priv->search_column = -1;
1359   tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
1360   tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
1361   tree_view->priv->search_custom_entry_set = FALSE;
1362   tree_view->priv->typeselect_flush_timeout = 0;
1363   tree_view->priv->init_hadjust_value = TRUE;
1364   tree_view->priv->width = 0;
1365
1366   tree_view->priv->hover_selection = FALSE;
1367   tree_view->priv->hover_expand = FALSE;
1368
1369   tree_view->priv->level_indentation = 0;
1370
1371   tree_view->priv->rubber_banding_enable = FALSE;
1372
1373   tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
1374   tree_view->priv->tree_lines_enabled = FALSE;
1375
1376   tree_view->priv->tooltip_column = -1;
1377
1378   tree_view->priv->post_validation_flag = FALSE;
1379
1380   tree_view->priv->last_button_x = -1;
1381   tree_view->priv->last_button_y = -1;
1382 }
1383
1384 \f
1385
1386 /* GObject Methods
1387  */
1388
1389 static void
1390 gtk_tree_view_set_property (GObject         *object,
1391                             guint            prop_id,
1392                             const GValue    *value,
1393                             GParamSpec      *pspec)
1394 {
1395   GtkTreeView *tree_view;
1396
1397   tree_view = GTK_TREE_VIEW (object);
1398
1399   switch (prop_id)
1400     {
1401     case PROP_MODEL:
1402       gtk_tree_view_set_model (tree_view, g_value_get_object (value));
1403       break;
1404     case PROP_HADJUSTMENT:
1405       gtk_tree_view_set_hadjustment (tree_view, g_value_get_object (value));
1406       break;
1407     case PROP_VADJUSTMENT:
1408       gtk_tree_view_set_vadjustment (tree_view, g_value_get_object (value));
1409       break;
1410     case PROP_HEADERS_VISIBLE:
1411       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1412       break;
1413     case PROP_HEADERS_CLICKABLE:
1414       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1415       break;
1416     case PROP_EXPANDER_COLUMN:
1417       gtk_tree_view_set_expander_column (tree_view, g_value_get_object (value));
1418       break;
1419     case PROP_REORDERABLE:
1420       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
1421       break;
1422     case PROP_RULES_HINT:
1423       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1424       break;
1425     case PROP_ENABLE_SEARCH:
1426       gtk_tree_view_set_enable_search (tree_view, g_value_get_boolean (value));
1427       break;
1428     case PROP_SEARCH_COLUMN:
1429       gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
1430       break;
1431     case PROP_FIXED_HEIGHT_MODE:
1432       gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
1433       break;
1434     case PROP_HOVER_SELECTION:
1435       tree_view->priv->hover_selection = g_value_get_boolean (value);
1436       break;
1437     case PROP_HOVER_EXPAND:
1438       tree_view->priv->hover_expand = g_value_get_boolean (value);
1439       break;
1440     case PROP_SHOW_EXPANDERS:
1441       gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
1442       break;
1443     case PROP_LEVEL_INDENTATION:
1444       tree_view->priv->level_indentation = g_value_get_int (value);
1445       break;
1446     case PROP_RUBBER_BANDING:
1447       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1448       break;
1449     case PROP_ENABLE_GRID_LINES:
1450       gtk_tree_view_set_grid_lines (tree_view, g_value_get_enum (value));
1451       break;
1452     case PROP_ENABLE_TREE_LINES:
1453       gtk_tree_view_set_enable_tree_lines (tree_view, g_value_get_boolean (value));
1454       break;
1455     case PROP_TOOLTIP_COLUMN:
1456       gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
1457       break;
1458     default:
1459       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1460       break;
1461     }
1462 }
1463
1464 static void
1465 gtk_tree_view_get_property (GObject    *object,
1466                             guint       prop_id,
1467                             GValue     *value,
1468                             GParamSpec *pspec)
1469 {
1470   GtkTreeView *tree_view;
1471
1472   tree_view = GTK_TREE_VIEW (object);
1473
1474   switch (prop_id)
1475     {
1476     case PROP_MODEL:
1477       g_value_set_object (value, tree_view->priv->model);
1478       break;
1479     case PROP_HADJUSTMENT:
1480       g_value_set_object (value, tree_view->priv->hadjustment);
1481       break;
1482     case PROP_VADJUSTMENT:
1483       g_value_set_object (value, tree_view->priv->vadjustment);
1484       break;
1485     case PROP_HEADERS_VISIBLE:
1486       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
1487       break;
1488     case PROP_HEADERS_CLICKABLE:
1489       g_value_set_boolean (value, gtk_tree_view_get_headers_clickable (tree_view));
1490       break;
1491     case PROP_EXPANDER_COLUMN:
1492       g_value_set_object (value, tree_view->priv->expander_column);
1493       break;
1494     case PROP_REORDERABLE:
1495       g_value_set_boolean (value, tree_view->priv->reorderable);
1496       break;
1497     case PROP_RULES_HINT:
1498       g_value_set_boolean (value, tree_view->priv->has_rules);
1499       break;
1500     case PROP_ENABLE_SEARCH:
1501       g_value_set_boolean (value, tree_view->priv->enable_search);
1502       break;
1503     case PROP_SEARCH_COLUMN:
1504       g_value_set_int (value, tree_view->priv->search_column);
1505       break;
1506     case PROP_FIXED_HEIGHT_MODE:
1507       g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
1508       break;
1509     case PROP_HOVER_SELECTION:
1510       g_value_set_boolean (value, tree_view->priv->hover_selection);
1511       break;
1512     case PROP_HOVER_EXPAND:
1513       g_value_set_boolean (value, tree_view->priv->hover_expand);
1514       break;
1515     case PROP_SHOW_EXPANDERS:
1516       g_value_set_boolean (value, GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS));
1517       break;
1518     case PROP_LEVEL_INDENTATION:
1519       g_value_set_int (value, tree_view->priv->level_indentation);
1520       break;
1521     case PROP_RUBBER_BANDING:
1522       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1523       break;
1524     case PROP_ENABLE_GRID_LINES:
1525       g_value_set_enum (value, tree_view->priv->grid_lines);
1526       break;
1527     case PROP_ENABLE_TREE_LINES:
1528       g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
1529       break;
1530     case PROP_TOOLTIP_COLUMN:
1531       g_value_set_int (value, tree_view->priv->tooltip_column);
1532       break;
1533     default:
1534       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1535       break;
1536     }
1537 }
1538
1539 static void
1540 gtk_tree_view_finalize (GObject *object)
1541 {
1542   G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
1543 }
1544
1545 \f
1546
1547 static void
1548 gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
1549                                    GtkBuilder  *builder,
1550                                    GObject     *child,
1551                                    const gchar *type)
1552 {
1553   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (child));
1554 }
1555
1556 /* GtkObject Methods
1557  */
1558
1559 static void
1560 gtk_tree_view_free_rbtree (GtkTreeView *tree_view)
1561 {
1562   _gtk_rbtree_free (tree_view->priv->tree);
1563
1564   tree_view->priv->tree = NULL;
1565   tree_view->priv->button_pressed_node = NULL;
1566   tree_view->priv->button_pressed_tree = NULL;
1567   tree_view->priv->prelight_tree = NULL;
1568   tree_view->priv->prelight_node = NULL;
1569   tree_view->priv->expanded_collapsed_node = NULL;
1570   tree_view->priv->expanded_collapsed_tree = NULL;
1571 }
1572
1573 static void
1574 gtk_tree_view_destroy (GtkObject *object)
1575 {
1576   GtkTreeView *tree_view = GTK_TREE_VIEW (object);
1577   GList *list;
1578
1579   gtk_tree_view_stop_editing (tree_view, TRUE);
1580
1581   if (tree_view->priv->columns != NULL)
1582     {
1583       list = tree_view->priv->columns;
1584       while (list)
1585         {
1586           GtkTreeViewColumn *column;
1587           column = GTK_TREE_VIEW_COLUMN (list->data);
1588           list = list->next;
1589           gtk_tree_view_remove_column (tree_view, column);
1590         }
1591       tree_view->priv->columns = NULL;
1592     }
1593
1594   if (tree_view->priv->tree != NULL)
1595     {
1596       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
1597
1598       gtk_tree_view_free_rbtree (tree_view);
1599     }
1600
1601   if (tree_view->priv->selection != NULL)
1602     {
1603       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
1604       g_object_unref (tree_view->priv->selection);
1605       tree_view->priv->selection = NULL;
1606     }
1607
1608   if (tree_view->priv->scroll_to_path != NULL)
1609     {
1610       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
1611       tree_view->priv->scroll_to_path = NULL;
1612     }
1613
1614   if (tree_view->priv->drag_dest_row != NULL)
1615     {
1616       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
1617       tree_view->priv->drag_dest_row = NULL;
1618     }
1619
1620   if (tree_view->priv->top_row != NULL)
1621     {
1622       gtk_tree_row_reference_free (tree_view->priv->top_row);
1623       tree_view->priv->top_row = NULL;
1624     }
1625
1626   if (tree_view->priv->column_drop_func_data &&
1627       tree_view->priv->column_drop_func_data_destroy)
1628     {
1629       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
1630       tree_view->priv->column_drop_func_data = NULL;
1631     }
1632
1633   if (tree_view->priv->destroy_count_destroy &&
1634       tree_view->priv->destroy_count_data)
1635     {
1636       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
1637       tree_view->priv->destroy_count_data = NULL;
1638     }
1639
1640   gtk_tree_row_reference_free (tree_view->priv->cursor);
1641   tree_view->priv->cursor = NULL;
1642
1643   gtk_tree_row_reference_free (tree_view->priv->anchor);
1644   tree_view->priv->anchor = NULL;
1645
1646   /* destroy interactive search dialog */
1647   if (tree_view->priv->search_window)
1648     {
1649       gtk_widget_destroy (tree_view->priv->search_window);
1650       tree_view->priv->search_window = NULL;
1651       tree_view->priv->search_entry = NULL;
1652       if (tree_view->priv->typeselect_flush_timeout)
1653         {
1654           g_source_remove (tree_view->priv->typeselect_flush_timeout);
1655           tree_view->priv->typeselect_flush_timeout = 0;
1656         }
1657     }
1658
1659   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
1660     {
1661       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
1662       tree_view->priv->search_user_data = NULL;
1663     }
1664
1665   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
1666     {
1667       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
1668       tree_view->priv->search_position_user_data = NULL;
1669     }
1670
1671   if (tree_view->priv->row_separator_destroy && tree_view->priv->row_separator_data)
1672     {
1673       tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
1674       tree_view->priv->row_separator_data = NULL;
1675     }
1676
1677   gtk_tree_view_set_model (tree_view, NULL);
1678
1679   if (tree_view->priv->hadjustment)
1680     {
1681       g_object_unref (tree_view->priv->hadjustment);
1682       tree_view->priv->hadjustment = NULL;
1683     }
1684   if (tree_view->priv->vadjustment)
1685     {
1686       g_object_unref (tree_view->priv->vadjustment);
1687       tree_view->priv->vadjustment = NULL;
1688     }
1689
1690   GTK_OBJECT_CLASS (gtk_tree_view_parent_class)->destroy (object);
1691 }
1692
1693 \f
1694
1695 /* GtkWidget Methods
1696  */
1697
1698 /* GtkWidget::map helper */
1699 static void
1700 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
1701 {
1702   GList *list;
1703
1704   g_return_if_fail (GTK_WIDGET_MAPPED (tree_view));
1705
1706   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
1707     {
1708       GtkTreeViewColumn *column;
1709
1710       for (list = tree_view->priv->columns; list; list = list->next)
1711         {
1712           column = list->data;
1713           if (GTK_WIDGET_VISIBLE (column->button) &&
1714               !GTK_WIDGET_MAPPED (column->button))
1715             gtk_widget_map (column->button);
1716         }
1717       for (list = tree_view->priv->columns; list; list = list->next)
1718         {
1719           column = list->data;
1720           if (column->visible == FALSE)
1721             continue;
1722           if (column->resizable)
1723             {
1724               gdk_window_raise (column->window);
1725               gdk_window_show (column->window);
1726             }
1727           else
1728             gdk_window_hide (column->window);
1729         }
1730       gdk_window_show (tree_view->priv->header_window);
1731     }
1732 }
1733
1734 static void
1735 gtk_tree_view_map (GtkWidget *widget)
1736 {
1737   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1738   GList *tmp_list;
1739
1740   GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
1741
1742   tmp_list = tree_view->priv->children;
1743   while (tmp_list)
1744     {
1745       GtkTreeViewChild *child = tmp_list->data;
1746       tmp_list = tmp_list->next;
1747
1748       if (GTK_WIDGET_VISIBLE (child->widget))
1749         {
1750           if (!GTK_WIDGET_MAPPED (child->widget))
1751             gtk_widget_map (child->widget);
1752         }
1753     }
1754   gdk_window_show (tree_view->priv->bin_window);
1755
1756   gtk_tree_view_map_buttons (tree_view);
1757
1758   gdk_window_show (widget->window);
1759 }
1760
1761 static void
1762 gtk_tree_view_realize (GtkWidget *widget)
1763 {
1764   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1765   GList *tmp_list;
1766   GdkWindowAttr attributes;
1767   gint attributes_mask;
1768
1769   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1770
1771   /* Make the main, clipping window */
1772   attributes.window_type = GDK_WINDOW_CHILD;
1773   attributes.x = widget->allocation.x;
1774   attributes.y = widget->allocation.y;
1775   attributes.width = widget->allocation.width;
1776   attributes.height = widget->allocation.height;
1777   attributes.wclass = GDK_INPUT_OUTPUT;
1778   attributes.visual = gtk_widget_get_visual (widget);
1779   attributes.colormap = gtk_widget_get_colormap (widget);
1780   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
1781
1782   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
1783
1784   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
1785                                    &attributes, attributes_mask);
1786   gdk_window_set_user_data (widget->window, widget);
1787
1788   /* Make the window for the tree */
1789   attributes.x = 0;
1790   attributes.y = TREE_VIEW_HEADER_HEIGHT (tree_view);
1791   attributes.width = MAX (tree_view->priv->width, widget->allocation.width);
1792   attributes.height = widget->allocation.height;
1793   attributes.event_mask = (GDK_EXPOSURE_MASK |
1794                            GDK_SCROLL_MASK |
1795                            GDK_POINTER_MOTION_MASK |
1796                            GDK_ENTER_NOTIFY_MASK |
1797                            GDK_LEAVE_NOTIFY_MASK |
1798                            GDK_BUTTON_PRESS_MASK |
1799                            GDK_BUTTON_RELEASE_MASK |
1800                            gtk_widget_get_events (widget));
1801
1802   tree_view->priv->bin_window = gdk_window_new (widget->window,
1803                                                 &attributes, attributes_mask);
1804   gdk_window_set_user_data (tree_view->priv->bin_window, widget);
1805
1806   /* Make the column header window */
1807   attributes.x = 0;
1808   attributes.y = 0;
1809   attributes.width = MAX (tree_view->priv->width, widget->allocation.width);
1810   attributes.height = tree_view->priv->header_height;
1811   attributes.event_mask = (GDK_EXPOSURE_MASK |
1812                            GDK_SCROLL_MASK |
1813                            GDK_BUTTON_PRESS_MASK |
1814                            GDK_BUTTON_RELEASE_MASK |
1815                            GDK_KEY_PRESS_MASK |
1816                            GDK_KEY_RELEASE_MASK |
1817                            gtk_widget_get_events (widget));
1818
1819   tree_view->priv->header_window = gdk_window_new (widget->window,
1820                                                    &attributes, attributes_mask);
1821   gdk_window_set_user_data (tree_view->priv->header_window, widget);
1822
1823   /* Add them all up. */
1824   widget->style = gtk_style_attach (widget->style, widget->window);
1825   gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
1826   gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
1827   gtk_style_set_background (widget->style, tree_view->priv->header_window, GTK_STATE_NORMAL);
1828
1829   tmp_list = tree_view->priv->children;
1830   while (tmp_list)
1831     {
1832       GtkTreeViewChild *child = tmp_list->data;
1833       tmp_list = tmp_list->next;
1834
1835       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
1836     }
1837
1838   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
1839     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
1840
1841   /* Need to call those here, since they create GCs */
1842   gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
1843   gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
1844
1845   install_presize_handler (tree_view);
1846 }
1847
1848 static void
1849 gtk_tree_view_unrealize (GtkWidget *widget)
1850 {
1851   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1852   GtkTreeViewPrivate *priv = tree_view->priv;
1853   GList *list;
1854
1855   if (priv->scroll_timeout != 0)
1856     {
1857       g_source_remove (priv->scroll_timeout);
1858       priv->scroll_timeout = 0;
1859     }
1860
1861   if (priv->auto_expand_timeout != 0)
1862     {
1863       g_source_remove (priv->auto_expand_timeout);
1864       priv->auto_expand_timeout = 0;
1865     }
1866
1867   if (priv->open_dest_timeout != 0)
1868     {
1869       g_source_remove (priv->open_dest_timeout);
1870       priv->open_dest_timeout = 0;
1871     }
1872
1873   remove_expand_collapse_timeout (tree_view);
1874
1875   if (priv->presize_handler_timer != 0)
1876     {
1877       g_source_remove (priv->presize_handler_timer);
1878       priv->presize_handler_timer = 0;
1879     }
1880
1881   if (priv->validate_rows_timer != 0)
1882     {
1883       g_source_remove (priv->validate_rows_timer);
1884       priv->validate_rows_timer = 0;
1885     }
1886
1887   if (priv->scroll_sync_timer != 0)
1888     {
1889       g_source_remove (priv->scroll_sync_timer);
1890       priv->scroll_sync_timer = 0;
1891     }
1892
1893   if (priv->typeselect_flush_timeout)
1894     {
1895       g_source_remove (priv->typeselect_flush_timeout);
1896       priv->typeselect_flush_timeout = 0;
1897     }
1898
1899   for (list = priv->columns; list; list = list->next)
1900     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
1901
1902   gdk_window_set_user_data (priv->bin_window, NULL);
1903   gdk_window_destroy (priv->bin_window);
1904   priv->bin_window = NULL;
1905
1906   gdk_window_set_user_data (priv->header_window, NULL);
1907   gdk_window_destroy (priv->header_window);
1908   priv->header_window = NULL;
1909
1910   if (priv->drag_window)
1911     {
1912       gdk_window_set_user_data (priv->drag_window, NULL);
1913       gdk_window_destroy (priv->drag_window);
1914       priv->drag_window = NULL;
1915     }
1916
1917   if (priv->drag_highlight_window)
1918     {
1919       gdk_window_set_user_data (priv->drag_highlight_window, NULL);
1920       gdk_window_destroy (priv->drag_highlight_window);
1921       priv->drag_highlight_window = NULL;
1922     }
1923
1924   if (priv->tree_line_gc)
1925     {
1926       g_object_unref (priv->tree_line_gc);
1927       priv->tree_line_gc = NULL;
1928     }
1929
1930   if (priv->grid_line_gc)
1931     {
1932       g_object_unref (priv->grid_line_gc);
1933       priv->grid_line_gc = NULL;
1934     }
1935
1936   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
1937 }
1938
1939 /* GtkWidget::size_request helper */
1940 static void
1941 gtk_tree_view_size_request_columns (GtkTreeView *tree_view)
1942 {
1943   GList *list;
1944
1945   tree_view->priv->header_height = 0;
1946
1947   if (tree_view->priv->model)
1948     {
1949       for (list = tree_view->priv->columns; list; list = list->next)
1950         {
1951           GtkRequisition requisition;
1952           GtkTreeViewColumn *column = list->data;
1953
1954           if (column->button == NULL)
1955             continue;
1956
1957           column = list->data;
1958
1959           gtk_widget_size_request (column->button, &requisition);
1960           column->button_request = requisition.width;
1961           tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
1962         }
1963     }
1964 }
1965
1966
1967 /* Called only by ::size_request */
1968 static void
1969 gtk_tree_view_update_size (GtkTreeView *tree_view)
1970 {
1971   GList *list;
1972   GtkTreeViewColumn *column;
1973   gint i;
1974
1975   if (tree_view->priv->model == NULL)
1976     {
1977       tree_view->priv->width = 0;
1978       tree_view->priv->prev_width = 0;
1979       tree_view->priv->height = 0;
1980       return;
1981     }
1982
1983   tree_view->priv->prev_width = tree_view->priv->width;
1984   tree_view->priv->width = 0;
1985
1986   /* keep this in sync with size_allocate below */
1987   for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
1988     {
1989       gint real_requested_width = 0;
1990       column = list->data;
1991       if (!column->visible)
1992         continue;
1993
1994       if (column->use_resized_width)
1995         {
1996           real_requested_width = column->resized_width;
1997         }
1998       else if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
1999         {
2000           real_requested_width = column->fixed_width;
2001         }
2002       else if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
2003         {
2004           real_requested_width = MAX (column->requested_width, column->button_request);
2005         }
2006       else
2007         {
2008           real_requested_width = column->requested_width;
2009         }
2010
2011       if (column->min_width != -1)
2012         real_requested_width = MAX (real_requested_width, column->min_width);
2013       if (column->max_width != -1)
2014         real_requested_width = MIN (real_requested_width, column->max_width);
2015
2016       tree_view->priv->width += real_requested_width;
2017     }
2018
2019   if (tree_view->priv->tree == NULL)
2020     tree_view->priv->height = 0;
2021   else
2022     tree_view->priv->height = tree_view->priv->tree->root->offset;
2023 }
2024
2025 static void
2026 gtk_tree_view_size_request (GtkWidget      *widget,
2027                             GtkRequisition *requisition)
2028 {
2029   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2030   GList *tmp_list;
2031
2032   /* we validate some rows initially just to make sure we have some size.
2033    * In practice, with a lot of static lists, this should get a good width.
2034    */
2035   do_validate_rows (tree_view, FALSE);
2036   gtk_tree_view_size_request_columns (tree_view);
2037   gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
2038
2039   requisition->width = tree_view->priv->width;
2040   requisition->height = tree_view->priv->height + TREE_VIEW_HEADER_HEIGHT (tree_view);
2041
2042   tmp_list = tree_view->priv->children;
2043
2044   while (tmp_list)
2045     {
2046       GtkTreeViewChild *child = tmp_list->data;
2047       GtkRequisition child_requisition;
2048
2049       tmp_list = tmp_list->next;
2050
2051       if (GTK_WIDGET_VISIBLE (child->widget))
2052         gtk_widget_size_request (child->widget, &child_requisition);
2053     }
2054 }
2055
2056
2057 static void
2058 invalidate_column (GtkTreeView       *tree_view,
2059                    GtkTreeViewColumn *column)
2060 {
2061   gint column_offset = 0;
2062   GList *list;
2063   GtkWidget *widget = GTK_WIDGET (tree_view);
2064   gboolean rtl;
2065
2066   if (!GTK_WIDGET_REALIZED (widget))
2067     return;
2068
2069   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2070   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2071        list;
2072        list = (rtl ? list->prev : list->next))
2073     {
2074       GtkTreeViewColumn *tmpcolumn = list->data;
2075       if (tmpcolumn == column)
2076         {
2077           GdkRectangle invalid_rect;
2078
2079           invalid_rect.x = column_offset;
2080           invalid_rect.y = 0;
2081           invalid_rect.width = column->width;
2082           invalid_rect.height = widget->allocation.height;
2083
2084           gdk_window_invalidate_rect (widget->window, &invalid_rect, TRUE);
2085           break;
2086         }
2087
2088       column_offset += tmpcolumn->width;
2089     }
2090 }
2091
2092 static void
2093 invalidate_last_column (GtkTreeView *tree_view)
2094 {
2095   GList *last_column;
2096   gboolean rtl;
2097
2098   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2099
2100   for (last_column = (rtl ? g_list_first (tree_view->priv->columns) : g_list_last (tree_view->priv->columns));
2101        last_column;
2102        last_column = (rtl ? last_column->next : last_column->prev))
2103     {
2104       if (GTK_TREE_VIEW_COLUMN (last_column->data)->visible)
2105         {
2106           invalidate_column (tree_view, last_column->data);
2107           return;
2108         }
2109     }
2110 }
2111
2112 static gint
2113 gtk_tree_view_get_real_requested_width_from_column (GtkTreeView       *tree_view,
2114                                                     GtkTreeViewColumn *column)
2115 {
2116   gint real_requested_width;
2117
2118   if (column->use_resized_width)
2119     {
2120       real_requested_width = column->resized_width;
2121     }
2122   else if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
2123     {
2124       real_requested_width = column->fixed_width;
2125     }
2126   else if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
2127     {
2128       real_requested_width = MAX (column->requested_width, column->button_request);
2129     }
2130   else
2131     {
2132       real_requested_width = column->requested_width;
2133       if (real_requested_width < 0)
2134         real_requested_width = 0;
2135     }
2136
2137   if (column->min_width != -1)
2138     real_requested_width = MAX (real_requested_width, column->min_width);
2139   if (column->max_width != -1)
2140     real_requested_width = MIN (real_requested_width, column->max_width);
2141
2142   return real_requested_width;
2143 }
2144
2145 static gint
2146 gtk_tree_view_get_real_natural_width_from_column (GtkTreeView       *tree_view,
2147                                                   GtkTreeViewColumn *column)
2148 {
2149   GtkTreeViewColumnPrivate *column_priv;
2150   GtkRequisition button_natural_size;
2151   gint column_natural_width;
2152
2153   column_priv = GTK_TREE_VIEW_COLUMN_GET_PRIVATE (column);
2154   column_natural_width = column_priv->natural_width;
2155
2156   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
2157     {
2158       gtk_extended_layout_get_desired_size (GTK_EXTENDED_LAYOUT (column->button),
2159                                             NULL, &button_natural_size);
2160
2161       column_natural_width = MAX (column_natural_width, button_natural_size.width);
2162     }
2163
2164   return column_natural_width;
2165 }
2166
2167 /* GtkWidget::size_allocate helper */
2168 static void
2169 gtk_tree_view_size_allocate_columns (GtkWidget *widget,
2170                                      gboolean  *width_changed)
2171 {
2172   GtkTreeView *tree_view;
2173   GList *list, *first_column, *last_column;
2174   GtkTreeViewColumn *column;
2175   GtkAllocation allocation;
2176   gint width = 0, natural_width;
2177   gint extra, extra_per_column, extra_for_last;
2178   gint full_requested_width = 0;
2179   gint full_natural_width = 0;
2180   gint number_of_expand_columns = 0;
2181   gboolean column_changed = FALSE;
2182   gboolean rtl;
2183   gboolean update_expand;
2184
2185   tree_view = GTK_TREE_VIEW (widget);
2186
2187   for (last_column = g_list_last (tree_view->priv->columns);
2188        last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible);
2189        last_column = last_column->prev)
2190     ;
2191   if (last_column == NULL)
2192     return;
2193
2194   for (first_column = g_list_first (tree_view->priv->columns);
2195        first_column && !(GTK_TREE_VIEW_COLUMN (first_column->data)->visible);
2196        first_column = first_column->next)
2197     ;
2198
2199   allocation.y = 0;
2200   allocation.height = tree_view->priv->header_height;
2201
2202   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2203
2204   /* find out how many extra space and expandable columns we have */
2205   for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
2206     {
2207       column = (GtkTreeViewColumn *)list->data;
2208
2209       if (!column->visible)
2210         continue;
2211
2212       full_requested_width += gtk_tree_view_get_real_requested_width_from_column (tree_view, column);
2213       full_natural_width += gtk_tree_view_get_real_natural_width_from_column (tree_view, column);
2214
2215       if (column->expand)
2216         number_of_expand_columns++;
2217     }
2218
2219   /* Only update the expand value if the width of the widget has changed,
2220    * or the number of expand columns has changed, or if there are no expand
2221    * columns, or if we didn't have an size-allocation yet after the
2222    * last validated node.
2223    */
2224   update_expand = (width_changed && *width_changed == TRUE)
2225       || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns
2226       || number_of_expand_columns == 0
2227       || tree_view->priv->post_validation_flag == TRUE;
2228
2229   tree_view->priv->post_validation_flag = FALSE;
2230
2231   if (!update_expand)
2232     {
2233       extra = tree_view->priv->last_extra_space;
2234       extra_for_last = MAX (widget->allocation.width - full_requested_width - extra, 0);
2235     }
2236   else
2237     {
2238       full_natural_width -= full_requested_width;
2239       extra = MAX (widget->allocation.width - full_requested_width, 0);
2240       natural_width = MIN (extra, full_natural_width);
2241       extra_for_last = 0;
2242
2243       tree_view->priv->last_extra_space = extra;
2244     }
2245
2246   if (number_of_expand_columns > 0)
2247     extra_per_column = extra/number_of_expand_columns;
2248   else
2249     extra_per_column = 0;
2250
2251   if (update_expand)
2252     {
2253       tree_view->priv->last_extra_space_per_column = extra_per_column;
2254       tree_view->priv->last_number_of_expand_columns = number_of_expand_columns;
2255     }
2256
2257   for (list = (rtl ? last_column : first_column);
2258        list != (rtl ? first_column->prev : last_column->next);
2259        list = (rtl ? list->prev : list->next))
2260     {
2261       gint real_requested_width = 0;
2262       gint real_natural_width = 0;
2263       gint old_width;
2264
2265       column = list->data;
2266       old_width = column->width;
2267
2268       if (!column->visible)
2269         continue;
2270
2271       /* We need to handle the dragged button specially.
2272        */
2273       if (column == tree_view->priv->drag_column)
2274         {
2275           GtkAllocation drag_allocation;
2276           gdk_drawable_get_size (tree_view->priv->drag_window,
2277                                  &(drag_allocation.width),
2278                                  &(drag_allocation.height));
2279           drag_allocation.x = 0;
2280           drag_allocation.y = 0;
2281           gtk_widget_size_allocate (tree_view->priv->drag_column->button,
2282                                     &drag_allocation);
2283           width += drag_allocation.width;
2284           continue;
2285         }
2286
2287       real_requested_width = gtk_tree_view_get_real_requested_width_from_column (tree_view, column);
2288       real_natural_width = gtk_tree_view_get_real_natural_width_from_column (tree_view, column);
2289       real_natural_width -= real_requested_width;
2290
2291       allocation.x = width;
2292       column->width = real_requested_width;
2293
2294       if (full_natural_width > 0)
2295         column->width += natural_width * real_natural_width / full_natural_width;
2296       if (column->expand)
2297         {
2298           if (number_of_expand_columns == 1)
2299             {
2300               /* We add the remander to the last column as
2301                * */
2302               column->width += extra;
2303             }
2304           else
2305             {
2306               column->width += extra_per_column;
2307               extra -= extra_per_column;
2308               number_of_expand_columns --;
2309             }
2310         }
2311       else if (number_of_expand_columns == 0 &&
2312                list == last_column)
2313         {
2314           column->width += extra;
2315         }
2316
2317       /* In addition to expand, the last column can get even more
2318        * extra space so all available space is filled up.
2319        */
2320       if (extra_for_last > 0 && list == last_column)
2321         column->width += extra_for_last;
2322
2323       g_object_notify (G_OBJECT (column), "width");
2324
2325       allocation.width = column->width;
2326       width += column->width;
2327
2328       if (column->width > old_width)
2329         column_changed = TRUE;
2330
2331       gtk_widget_size_allocate (column->button, &allocation);
2332
2333       if (column->window)
2334         gdk_window_move_resize (column->window,
2335                                 allocation.x + (rtl ? 0 : allocation.width) - TREE_VIEW_DRAG_WIDTH/2,
2336                                 allocation.y,
2337                                 TREE_VIEW_DRAG_WIDTH, allocation.height);
2338     }
2339
2340   /* We change the width here.  The user might have been resizing columns,
2341    * so the total width of the tree view changes.
2342    */
2343   tree_view->priv->width = width;
2344   if (width_changed)
2345     *width_changed = TRUE;
2346
2347   if (column_changed)
2348     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
2349 }
2350
2351
2352 static void
2353 gtk_tree_view_size_allocate (GtkWidget     *widget,
2354                              GtkAllocation *allocation)
2355 {
2356   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2357   GList *tmp_list;
2358   gboolean width_changed = FALSE;
2359   gint old_width = widget->allocation.width;
2360
2361   if (allocation->width != widget->allocation.width)
2362     width_changed = TRUE;
2363
2364   widget->allocation = *allocation;
2365
2366   tmp_list = tree_view->priv->children;
2367
2368   while (tmp_list)
2369     {
2370       GtkAllocation allocation;
2371
2372       GtkTreeViewChild *child = tmp_list->data;
2373       tmp_list = tmp_list->next;
2374
2375       /* totally ignore our child's requisition */
2376       allocation.x = child->x;
2377       allocation.y = child->y;
2378       allocation.width = child->width;
2379       allocation.height = child->height;
2380       gtk_widget_size_allocate (child->widget, &allocation);
2381     }
2382
2383   /* We size-allocate the columns first because the width of the
2384    * tree view (used in updating the adjustments below) might change.
2385    */
2386   gtk_tree_view_size_allocate_columns (widget, &width_changed);
2387
2388   tree_view->priv->hadjustment->page_size = allocation->width;
2389   tree_view->priv->hadjustment->page_increment = allocation->width * 0.9;
2390   tree_view->priv->hadjustment->step_increment = allocation->width * 0.1;
2391   tree_view->priv->hadjustment->lower = 0;
2392   tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->page_size, tree_view->priv->width);
2393
2394   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2395     {
2396       if (allocation->width < tree_view->priv->width)
2397         {
2398           if (tree_view->priv->init_hadjust_value)
2399             {
2400               tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
2401               tree_view->priv->init_hadjust_value = FALSE;
2402             }
2403           else if (allocation->width != old_width)
2404             {
2405               tree_view->priv->hadjustment->value = CLAMP (tree_view->priv->hadjustment->value - allocation->width + old_width, 0, tree_view->priv->width - allocation->width);
2406             }
2407           else
2408             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);
2409         }
2410       else
2411         {
2412           tree_view->priv->hadjustment->value = 0;
2413           tree_view->priv->init_hadjust_value = TRUE;
2414         }
2415     }
2416   else
2417     if (tree_view->priv->hadjustment->value + allocation->width > tree_view->priv->width)
2418       tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
2419
2420   gtk_adjustment_changed (tree_view->priv->hadjustment);
2421
2422   tree_view->priv->vadjustment->page_size = allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view);
2423   tree_view->priv->vadjustment->step_increment = tree_view->priv->vadjustment->page_size * 0.1;
2424   tree_view->priv->vadjustment->page_increment = tree_view->priv->vadjustment->page_size * 0.9;
2425   tree_view->priv->vadjustment->lower = 0;
2426   tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->page_size, tree_view->priv->height);
2427
2428   gtk_adjustment_changed (tree_view->priv->vadjustment);
2429
2430   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2431   if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
2432     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2433   else if (tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
2434     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2435                               tree_view->priv->height - tree_view->priv->vadjustment->page_size);
2436   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2437     gtk_tree_view_top_row_to_dy (tree_view);
2438   else
2439     gtk_tree_view_dy_to_top_row (tree_view);
2440
2441   if (GTK_WIDGET_REALIZED (widget))
2442     {
2443       gdk_window_move_resize (widget->window,
2444                               allocation->x, allocation->y,
2445                               allocation->width, allocation->height);
2446       gdk_window_move_resize (tree_view->priv->header_window,
2447                               - (gint) tree_view->priv->hadjustment->value,
2448                               0,
2449                               MAX (tree_view->priv->width, allocation->width),
2450                               tree_view->priv->header_height);
2451       gdk_window_move_resize (tree_view->priv->bin_window,
2452                               - (gint) tree_view->priv->hadjustment->value,
2453                               TREE_VIEW_HEADER_HEIGHT (tree_view),
2454                               MAX (tree_view->priv->width, allocation->width),
2455                               allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view));
2456     }
2457
2458   if (tree_view->priv->tree == NULL)
2459     invalidate_empty_focus (tree_view);
2460
2461   if (GTK_WIDGET_REALIZED (widget))
2462     {
2463       gboolean has_expand_column = FALSE;
2464       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2465         {
2466           if (gtk_tree_view_column_get_expand (GTK_TREE_VIEW_COLUMN (tmp_list->data)))
2467             {
2468               has_expand_column = TRUE;
2469               break;
2470             }
2471         }
2472
2473       /* This little hack only works if we have an LTR locale, and no column has the  */
2474       if (width_changed)
2475         {
2476           if (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_LTR &&
2477               ! has_expand_column)
2478             invalidate_last_column (tree_view);
2479           else
2480             gtk_widget_queue_draw (widget);
2481         }
2482     }
2483 }
2484
2485 /* Grabs the focus and unsets the GTK_TREE_VIEW_DRAW_KEYFOCUS flag */
2486 static void
2487 grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
2488 {
2489   if (GTK_WIDGET_CAN_FOCUS (tree_view) && !GTK_WIDGET_HAS_FOCUS (tree_view))
2490     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
2491   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
2492 }
2493
2494 static inline gboolean
2495 row_is_separator (GtkTreeView *tree_view,
2496                   GtkTreeIter *iter,
2497                   GtkTreePath *path)
2498 {
2499   gboolean is_separator = FALSE;
2500
2501   if (tree_view->priv->row_separator_func)
2502     {
2503       GtkTreeIter tmpiter;
2504
2505       if (iter)
2506         tmpiter = *iter;
2507       else
2508         gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path);
2509
2510       is_separator = tree_view->priv->row_separator_func (tree_view->priv->model,
2511                                                           &tmpiter,
2512                                                           tree_view->priv->row_separator_data);
2513     }
2514
2515   return is_separator;
2516 }
2517
2518 static gboolean
2519 gtk_tree_view_button_press (GtkWidget      *widget,
2520                             GdkEventButton *event)
2521 {
2522   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2523   GList *list;
2524   GtkTreeViewColumn *column = NULL;
2525   gint i;
2526   GdkRectangle background_area;
2527   GdkRectangle cell_area;
2528   gint vertical_separator;
2529   gint horizontal_separator;
2530   gboolean path_is_selectable;
2531   gboolean rtl;
2532
2533   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2534   gtk_tree_view_stop_editing (tree_view, FALSE);
2535   gtk_widget_style_get (widget,
2536                         "vertical-separator", &vertical_separator,
2537                         "horizontal-separator", &horizontal_separator,
2538                         NULL);
2539
2540
2541   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2542    * we're done handling the button press.
2543    */
2544
2545   if (event->window == tree_view->priv->bin_window)
2546     {
2547       GtkRBNode *node;
2548       GtkRBTree *tree;
2549       GtkTreePath *path;
2550       gchar *path_string;
2551       gint depth;
2552       gint new_y;
2553       gint y_offset;
2554       gint dval;
2555       gint pre_val, aft_val;
2556       GtkTreeViewColumn *column = NULL;
2557       GtkCellRenderer *focus_cell = NULL;
2558       gint column_handled_click = FALSE;
2559       gboolean row_double_click = FALSE;
2560       gboolean rtl;
2561       gboolean node_selected;
2562
2563       /* Empty tree? */
2564       if (tree_view->priv->tree == NULL)
2565         {
2566           grab_focus_and_unset_draw_keyfocus (tree_view);
2567           return TRUE;
2568         }
2569
2570       /* are we in an arrow? */
2571       if (tree_view->priv->prelight_node &&
2572           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT) &&
2573           TREE_VIEW_DRAW_EXPANDERS (tree_view))
2574         {
2575           if (event->button == 1)
2576             {
2577               gtk_grab_add (widget);
2578               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2579               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2580               gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
2581                                         tree_view->priv->prelight_tree,
2582                                         tree_view->priv->prelight_node,
2583                                         event->x,
2584                                         event->y);
2585             }
2586
2587           grab_focus_and_unset_draw_keyfocus (tree_view);
2588           return TRUE;
2589         }
2590
2591       /* find the node that was clicked */
2592       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
2593       if (new_y < 0)
2594         new_y = 0;
2595       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
2596
2597       if (node == NULL)
2598         {
2599           /* We clicked in dead space */
2600           grab_focus_and_unset_draw_keyfocus (tree_view);
2601           return TRUE;
2602         }
2603
2604       /* Get the path and the node */
2605       path = _gtk_tree_view_find_path (tree_view, tree, node);
2606       path_is_selectable = !row_is_separator (tree_view, NULL, path);
2607
2608       if (!path_is_selectable)
2609         {
2610           gtk_tree_path_free (path);
2611           grab_focus_and_unset_draw_keyfocus (tree_view);
2612           return TRUE;
2613         }
2614
2615       depth = gtk_tree_path_get_depth (path);
2616       background_area.y = y_offset + event->y;
2617       background_area.height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
2618       background_area.x = 0;
2619
2620
2621       /* Let the column have a chance at selecting it. */
2622       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2623       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2624            list; list = (rtl ? list->prev : list->next))
2625         {
2626           GtkTreeViewColumn *candidate = list->data;
2627
2628           if (!candidate->visible)
2629             continue;
2630
2631           background_area.width = candidate->width;
2632           if ((background_area.x > (gint) event->x) ||
2633               (background_area.x + background_area.width <= (gint) event->x))
2634             {
2635               background_area.x += background_area.width;
2636               continue;
2637             }
2638
2639           /* we found the focus column */
2640           column = candidate;
2641           cell_area = background_area;
2642           cell_area.width -= horizontal_separator;
2643           cell_area.height -= vertical_separator;
2644           cell_area.x += horizontal_separator/2;
2645           cell_area.y += vertical_separator/2;
2646           if (gtk_tree_view_is_expander_column (tree_view, column))
2647             {
2648               if (!rtl)
2649                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
2650               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
2651
2652               if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
2653                 {
2654                   if (!rtl)
2655                     cell_area.x += depth * tree_view->priv->expander_size;
2656                   cell_area.width -= depth * tree_view->priv->expander_size;
2657                 }
2658             }
2659           break;
2660         }
2661
2662       if (column == NULL)
2663         {
2664           gtk_tree_path_free (path);
2665           grab_focus_and_unset_draw_keyfocus (tree_view);
2666           return FALSE;
2667         }
2668
2669       tree_view->priv->focus_column = column;
2670
2671       /* decide if we edit */
2672       if (event->type == GDK_BUTTON_PRESS && event->button == 1 &&
2673           !(event->state & gtk_accelerator_get_default_mod_mask ()))
2674         {
2675           GtkTreePath *anchor;
2676           GtkTreeIter iter;
2677
2678           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
2679           gtk_tree_view_column_cell_set_cell_data (column,
2680                                                    tree_view->priv->model,
2681                                                    &iter,
2682                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
2683                                                    node->children?TRUE:FALSE);
2684
2685           if (tree_view->priv->anchor)
2686             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
2687           else
2688             anchor = NULL;
2689
2690           if ((anchor && !gtk_tree_path_compare (anchor, path))
2691               || !_gtk_tree_view_column_has_editable_cell (column))
2692             {
2693               GtkCellEditable *cell_editable = NULL;
2694
2695               /* FIXME: get the right flags */
2696               guint flags = 0;
2697
2698               path_string = gtk_tree_path_to_string (path);
2699
2700               if (_gtk_tree_view_column_cell_event (column,
2701                                                     &cell_editable,
2702                                                     (GdkEvent *)event,
2703                                                     path_string,
2704                                                     &background_area,
2705                                                     &cell_area, flags))
2706                 {
2707                   if (cell_editable != NULL)
2708                     {
2709                       gint left, right;
2710                       GdkRectangle area;
2711
2712                       area = cell_area;
2713                       _gtk_tree_view_column_get_neighbor_sizes (column, _gtk_tree_view_column_get_edited_cell (column), &left, &right);
2714
2715                       area.x += left;
2716                       area.width -= right + left;
2717
2718                       gtk_tree_view_real_start_editing (tree_view,
2719                                                         column,
2720                                                         path,
2721                                                         cell_editable,
2722                                                         &area,
2723                                                         (GdkEvent *)event,
2724                                                         flags);
2725                       g_free (path_string);
2726                       gtk_tree_path_free (path);
2727                       gtk_tree_path_free (anchor);
2728                       return TRUE;
2729                     }
2730                   column_handled_click = TRUE;
2731                 }
2732               g_free (path_string);
2733             }
2734           if (anchor)
2735             gtk_tree_path_free (anchor);
2736         }
2737
2738       /* select */
2739       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
2740       pre_val = tree_view->priv->vadjustment->value;
2741
2742       /* we only handle selection modifications on the first button press
2743        */
2744       if (event->type == GDK_BUTTON_PRESS)
2745         {
2746           if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
2747             tree_view->priv->ctrl_pressed = TRUE;
2748           if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
2749             tree_view->priv->shift_pressed = TRUE;
2750
2751           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column, event->x - background_area.x);
2752           if (focus_cell)
2753             gtk_tree_view_column_focus_cell (column, focus_cell);
2754
2755           if (event->state & GDK_CONTROL_MASK)
2756             {
2757               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
2758               gtk_tree_view_real_toggle_cursor_row (tree_view);
2759             }
2760           else if (event->state & GDK_SHIFT_MASK)
2761             {
2762               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
2763               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
2764             }
2765           else
2766             {
2767               gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
2768             }
2769
2770           tree_view->priv->ctrl_pressed = FALSE;
2771           tree_view->priv->shift_pressed = FALSE;
2772         }
2773
2774       /* the treeview may have been scrolled because of _set_cursor,
2775        * correct here
2776        */
2777
2778       aft_val = tree_view->priv->vadjustment->value;
2779       dval = pre_val - aft_val;
2780
2781       cell_area.y += dval;
2782       background_area.y += dval;
2783
2784       /* Save press to possibly begin a drag
2785        */
2786       if (!column_handled_click &&
2787           !tree_view->priv->in_grab &&
2788           tree_view->priv->pressed_button < 0)
2789         {
2790           tree_view->priv->pressed_button = event->button;
2791           tree_view->priv->press_start_x = event->x;
2792           tree_view->priv->press_start_y = event->y;
2793
2794           if (tree_view->priv->rubber_banding_enable
2795               && !node_selected
2796               && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE)
2797             {
2798               tree_view->priv->press_start_y += tree_view->priv->dy;
2799               tree_view->priv->rubber_band_x = event->x;
2800               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
2801               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
2802
2803               if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
2804                 tree_view->priv->rubber_band_ctrl = TRUE;
2805               if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
2806                 tree_view->priv->rubber_band_shift = TRUE;
2807             }
2808         }
2809
2810       /* Test if a double click happened on the same row. */
2811       if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
2812         {
2813           if (tree_view->priv->last_button_x != -1)
2814             {
2815               int double_click_time, double_click_distance;
2816
2817               g_object_get (gtk_settings_get_default (),
2818                             "gtk-double-click-time", &double_click_time,
2819                             "gtk-double-click-distance", &double_click_distance,
2820                             NULL);
2821
2822               /* Same conditions as _gdk_event_button_generate */
2823               if ((event->time < tree_view->priv->last_button_time + double_click_time) &&
2824                   (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
2825                   (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
2826                 {
2827                   /* We do no longer compare paths of this row and the
2828                    * row clicked previously.  We use the double click
2829                    * distance to decide whether this is a valid click,
2830                    * allowing the mouse to slightly move over another row.
2831                    */
2832                   row_double_click = TRUE;
2833                 }
2834
2835               tree_view->priv->last_button_time = 0;
2836               tree_view->priv->last_button_x = -1;
2837               tree_view->priv->last_button_y = -1;
2838             }
2839           else
2840             {
2841               tree_view->priv->last_button_time = event->time;
2842               tree_view->priv->last_button_x = event->x;
2843               tree_view->priv->last_button_y = event->y;
2844             }
2845         }
2846
2847       if (row_double_click)
2848         {
2849           gtk_grab_remove (widget);
2850           gtk_tree_view_row_activated (tree_view, path, column);
2851
2852           if (tree_view->priv->pressed_button == event->button)
2853             tree_view->priv->pressed_button = -1;
2854         }
2855
2856       gtk_tree_path_free (path);
2857
2858       /* If we activated the row through a double click we don't want to grab
2859        * focus back, as moving focus to another widget is pretty common.
2860        */
2861       if (!row_double_click)
2862         grab_focus_and_unset_draw_keyfocus (tree_view);
2863
2864       return TRUE;
2865     }
2866
2867   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
2868    */
2869   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
2870     {
2871       column = list->data;
2872       if (event->window == column->window &&
2873           column->resizable &&
2874           column->window)
2875         {
2876           gpointer drag_data;
2877
2878           if (event->type == GDK_2BUTTON_PRESS &&
2879               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
2880             {
2881               column->use_resized_width = FALSE;
2882               _gtk_tree_view_column_autosize (tree_view, column);
2883               return TRUE;
2884             }
2885
2886           if (gdk_pointer_grab (column->window, FALSE,
2887                                 GDK_POINTER_MOTION_HINT_MASK |
2888                                 GDK_BUTTON1_MOTION_MASK |
2889                                 GDK_BUTTON_RELEASE_MASK,
2890                                 NULL, NULL, event->time))
2891             return FALSE;
2892
2893           gtk_grab_add (widget);
2894           GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
2895           column->resized_width = column->width - tree_view->priv->last_extra_space_per_column;
2896
2897           /* block attached dnd signal handler */
2898           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
2899           if (drag_data)
2900             g_signal_handlers_block_matched (widget,
2901                                              G_SIGNAL_MATCH_DATA,
2902                                              0, 0, NULL, NULL,
2903                                              drag_data);
2904
2905           tree_view->priv->drag_pos = i;
2906           tree_view->priv->x_drag = column->button->allocation.x + (rtl ? 0 : column->button->allocation.width);
2907
2908           if (!GTK_WIDGET_HAS_FOCUS (widget))
2909             gtk_widget_grab_focus (widget);
2910
2911           return TRUE;
2912         }
2913     }
2914   return FALSE;
2915 }
2916
2917 /* GtkWidget::button_release_event helper */
2918 static gboolean
2919 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
2920                                           GdkEventButton *event)
2921 {
2922   GtkTreeView *tree_view;
2923   GList *l;
2924   gboolean rtl;
2925
2926   tree_view = GTK_TREE_VIEW (widget);
2927
2928   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2929   gdk_display_pointer_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME);
2930   gdk_display_keyboard_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME);
2931
2932   /* Move the button back */
2933   g_object_ref (tree_view->priv->drag_column->button);
2934   gtk_container_remove (GTK_CONTAINER (tree_view), tree_view->priv->drag_column->button);
2935   gtk_widget_set_parent_window (tree_view->priv->drag_column->button, tree_view->priv->header_window);
2936   gtk_widget_set_parent (tree_view->priv->drag_column->button, GTK_WIDGET (tree_view));
2937   g_object_unref (tree_view->priv->drag_column->button);
2938   gtk_widget_queue_resize (widget);
2939   if (tree_view->priv->drag_column->resizable)
2940     {
2941       gdk_window_raise (tree_view->priv->drag_column->window);
2942       gdk_window_show (tree_view->priv->drag_column->window);
2943     }
2944   else
2945     gdk_window_hide (tree_view->priv->drag_column->window);
2946
2947   gtk_widget_grab_focus (tree_view->priv->drag_column->button);
2948
2949   if (rtl)
2950     {
2951       if (tree_view->priv->cur_reorder &&
2952           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
2953         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
2954                                          tree_view->priv->cur_reorder->right_column);
2955     }
2956   else
2957     {
2958       if (tree_view->priv->cur_reorder &&
2959           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
2960         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
2961                                          tree_view->priv->cur_reorder->left_column);
2962     }
2963   tree_view->priv->drag_column = NULL;
2964   gdk_window_hide (tree_view->priv->drag_window);
2965
2966   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
2967     g_slice_free (GtkTreeViewColumnReorder, l->data);
2968   g_list_free (tree_view->priv->column_drag_info);
2969   tree_view->priv->column_drag_info = NULL;
2970   tree_view->priv->cur_reorder = NULL;
2971
2972   if (tree_view->priv->drag_highlight_window)
2973     gdk_window_hide (tree_view->priv->drag_highlight_window);
2974
2975   /* Reset our flags */
2976   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
2977   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG);
2978
2979   return TRUE;
2980 }
2981
2982 /* GtkWidget::button_release_event helper */
2983 static gboolean
2984 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
2985                                             GdkEventButton *event)
2986 {
2987   GtkTreeView *tree_view;
2988   gpointer drag_data;
2989
2990   tree_view = GTK_TREE_VIEW (widget);
2991
2992   tree_view->priv->drag_pos = -1;
2993
2994   /* unblock attached dnd signal handler */
2995   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
2996   if (drag_data)
2997     g_signal_handlers_unblock_matched (widget,
2998                                        G_SIGNAL_MATCH_DATA,
2999                                        0, 0, NULL, NULL,
3000                                        drag_data);
3001
3002   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
3003   gtk_grab_remove (widget);
3004   gdk_display_pointer_ungrab (gdk_drawable_get_display (event->window),
3005                               event->time);
3006   return TRUE;
3007 }
3008
3009 static gboolean
3010 gtk_tree_view_button_release (GtkWidget      *widget,
3011                               GdkEventButton *event)
3012 {
3013   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3014
3015   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
3016     return gtk_tree_view_button_release_drag_column (widget, event);
3017
3018   if (tree_view->priv->rubber_band_status)
3019     gtk_tree_view_stop_rubber_band (tree_view);
3020
3021   if (tree_view->priv->pressed_button == event->button)
3022     tree_view->priv->pressed_button = -1;
3023
3024   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
3025     return gtk_tree_view_button_release_column_resize (widget, event);
3026
3027   if (tree_view->priv->button_pressed_node == NULL)
3028     return FALSE;
3029
3030   if (event->button == 1)
3031     {
3032       gtk_grab_remove (widget);
3033       if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
3034           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
3035         {
3036           GtkTreePath *path = NULL;
3037
3038           path = _gtk_tree_view_find_path (tree_view,
3039                                            tree_view->priv->button_pressed_tree,
3040                                            tree_view->priv->button_pressed_node);
3041           /* Actually activate the node */
3042           if (tree_view->priv->button_pressed_node->children == NULL)
3043             gtk_tree_view_real_expand_row (tree_view, path,
3044                                            tree_view->priv->button_pressed_tree,
3045                                            tree_view->priv->button_pressed_node,
3046                                            FALSE, TRUE);
3047           else
3048             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3049                                              tree_view->priv->button_pressed_tree,
3050                                              tree_view->priv->button_pressed_node, TRUE);
3051           gtk_tree_path_free (path);
3052         }
3053
3054       tree_view->priv->button_pressed_tree = NULL;
3055       tree_view->priv->button_pressed_node = NULL;
3056     }
3057
3058   return TRUE;
3059 }
3060
3061 static gboolean
3062 gtk_tree_view_grab_broken (GtkWidget          *widget,
3063                            GdkEventGrabBroken *event)
3064 {
3065   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3066
3067   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
3068     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3069
3070   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
3071     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3072
3073   return TRUE;
3074 }
3075
3076 #if 0
3077 static gboolean
3078 gtk_tree_view_configure (GtkWidget *widget,
3079                          GdkEventConfigure *event)
3080 {
3081   GtkTreeView *tree_view;
3082
3083   tree_view = GTK_TREE_VIEW (widget);
3084   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3085
3086   return FALSE;
3087 }
3088 #endif
3089
3090 /* GtkWidget::motion_event function set.
3091  */
3092
3093 static gboolean
3094 coords_are_over_arrow (GtkTreeView *tree_view,
3095                        GtkRBTree   *tree,
3096                        GtkRBNode   *node,
3097                        /* these are in bin window coords */
3098                        gint         x,
3099                        gint         y)
3100 {
3101   GdkRectangle arrow;
3102   gint x2;
3103
3104   if (!GTK_WIDGET_REALIZED (tree_view))
3105     return FALSE;
3106
3107   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3108     return FALSE;
3109
3110   arrow.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
3111
3112   arrow.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
3113
3114   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3115
3116   arrow.width = x2 - arrow.x;
3117
3118   return (x >= arrow.x &&
3119           x < (arrow.x + arrow.width) &&
3120           y >= arrow.y &&
3121           y < (arrow.y + arrow.height));
3122 }
3123
3124 static gboolean
3125 auto_expand_timeout (gpointer data)
3126 {
3127   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3128   GtkTreePath *path;
3129
3130   if (tree_view->priv->prelight_node)
3131     {
3132       path = _gtk_tree_view_find_path (tree_view,
3133                                        tree_view->priv->prelight_tree,
3134                                        tree_view->priv->prelight_node);
3135
3136       if (tree_view->priv->prelight_node->children)
3137         gtk_tree_view_collapse_row (tree_view, path);
3138       else
3139         gtk_tree_view_expand_row (tree_view, path, FALSE);
3140
3141       gtk_tree_path_free (path);
3142     }
3143
3144   tree_view->priv->auto_expand_timeout = 0;
3145
3146   return FALSE;
3147 }
3148
3149 static void
3150 remove_auto_expand_timeout (GtkTreeView *tree_view)
3151 {
3152   if (tree_view->priv->auto_expand_timeout != 0)
3153     {
3154       g_source_remove (tree_view->priv->auto_expand_timeout);
3155       tree_view->priv->auto_expand_timeout = 0;
3156     }
3157 }
3158
3159 static void
3160 do_prelight (GtkTreeView *tree_view,
3161              GtkRBTree   *tree,
3162              GtkRBNode   *node,
3163              /* these are in bin_window coords */
3164              gint         x,
3165              gint         y)
3166 {
3167   if (tree_view->priv->prelight_tree == tree &&
3168       tree_view->priv->prelight_node == node)
3169     {
3170       /*  We are still on the same node,
3171           but we might need to take care of the arrow  */
3172
3173       if (tree && node && TREE_VIEW_DRAW_EXPANDERS (tree_view))
3174         {
3175           gboolean over_arrow;
3176           gboolean flag_set;
3177
3178           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3179           flag_set = GTK_TREE_VIEW_FLAG_SET (tree_view,
3180                                              GTK_TREE_VIEW_ARROW_PRELIT);
3181
3182           if (over_arrow != flag_set)
3183             {
3184               if (over_arrow)
3185                 GTK_TREE_VIEW_SET_FLAG (tree_view,
3186                                         GTK_TREE_VIEW_ARROW_PRELIT);
3187               else
3188                 GTK_TREE_VIEW_UNSET_FLAG (tree_view,
3189                                           GTK_TREE_VIEW_ARROW_PRELIT);
3190
3191               gtk_tree_view_draw_arrow (tree_view, tree, node, x, y);
3192             }
3193         }
3194
3195       return;
3196     }
3197
3198   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3199     {
3200       /*  Unprelight the old node and arrow  */
3201
3202       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3203                              GTK_RBNODE_IS_PRELIT);
3204
3205       if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT)
3206           && TREE_VIEW_DRAW_EXPANDERS (tree_view))
3207         {
3208           GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
3209
3210           gtk_tree_view_draw_arrow (tree_view,
3211                                     tree_view->priv->prelight_tree,
3212                                     tree_view->priv->prelight_node,
3213                                     x,
3214                                     y);
3215         }
3216
3217       _gtk_tree_view_queue_draw_node (tree_view,
3218                                       tree_view->priv->prelight_tree,
3219                                       tree_view->priv->prelight_node,
3220                                       NULL);
3221     }
3222
3223
3224   if (tree_view->priv->hover_expand)
3225     remove_auto_expand_timeout (tree_view);
3226
3227   /*  Set the new prelight values  */
3228   tree_view->priv->prelight_node = node;
3229   tree_view->priv->prelight_tree = tree;
3230
3231   if (!node || !tree)
3232     return;
3233
3234   /*  Prelight the new node and arrow  */
3235
3236   if (TREE_VIEW_DRAW_EXPANDERS (tree_view)
3237       && coords_are_over_arrow (tree_view, tree, node, x, y))
3238     {
3239       GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
3240
3241       gtk_tree_view_draw_arrow (tree_view, tree, node, x, y);
3242     }
3243
3244   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3245
3246   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3247
3248   if (tree_view->priv->hover_expand)
3249     {
3250       tree_view->priv->auto_expand_timeout =
3251         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3252     }
3253 }
3254
3255 static void
3256 prelight_or_select (GtkTreeView *tree_view,
3257                     GtkRBTree   *tree,
3258                     GtkRBNode   *node,
3259                     /* these are in bin_window coords */
3260                     gint         x,
3261                     gint         y)
3262 {
3263   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3264
3265   if (tree_view->priv->hover_selection &&
3266       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3267       !(tree_view->priv->edited_column &&
3268         tree_view->priv->edited_column->editable_widget))
3269     {
3270       if (node)
3271         {
3272           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3273             {
3274               GtkTreePath *path;
3275
3276               path = _gtk_tree_view_find_path (tree_view, tree, node);
3277               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3278               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3279                 {
3280                   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
3281                   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE);
3282                 }
3283               gtk_tree_path_free (path);
3284             }
3285         }
3286
3287       else if (mode == GTK_SELECTION_SINGLE)
3288         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3289     }
3290
3291     do_prelight (tree_view, tree, node, x, y);
3292 }
3293
3294 static void
3295 ensure_unprelighted (GtkTreeView *tree_view)
3296 {
3297   do_prelight (tree_view,
3298                NULL, NULL,
3299                -1000, -1000); /* coords not possibly over an arrow */
3300
3301   g_assert (tree_view->priv->prelight_node == NULL);
3302 }
3303
3304
3305
3306
3307 /* Our motion arrow is either a box (in the case of the original spot)
3308  * or an arrow.  It is expander_size wide.
3309  */
3310 /*
3311  * 11111111111111
3312  * 01111111111110
3313  * 00111111111100
3314  * 00011111111000
3315  * 00001111110000
3316  * 00000111100000
3317  * 00000111100000
3318  * 00000111100000
3319  * ~ ~ ~ ~ ~ ~ ~
3320  * 00000111100000
3321  * 00000111100000
3322  * 00000111100000
3323  * 00001111110000
3324  * 00011111111000
3325  * 00111111111100
3326  * 01111111111110
3327  * 11111111111111
3328  */
3329
3330 static void
3331 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3332 {
3333   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3334   GtkWidget *widget = GTK_WIDGET (tree_view);
3335   GdkBitmap *mask = NULL;
3336   gint x;
3337   gint y;
3338   gint width;
3339   gint height;
3340   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3341   GdkWindowAttr attributes;
3342   guint attributes_mask;
3343
3344   if (!reorder ||
3345       reorder->left_column == tree_view->priv->drag_column ||
3346       reorder->right_column == tree_view->priv->drag_column)
3347     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3348   else if (reorder->left_column || reorder->right_column)
3349     {
3350       GdkRectangle visible_rect;
3351       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3352       if (reorder->left_column)
3353         x = reorder->left_column->button->allocation.x + reorder->left_column->button->allocation.width;
3354       else
3355         x = reorder->right_column->button->allocation.x;
3356
3357       if (x < visible_rect.x)
3358         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3359       else if (x > visible_rect.x + visible_rect.width)
3360         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3361       else
3362         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3363     }
3364
3365   /* We want to draw the rectangle over the initial location. */
3366   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3367     {
3368       GdkGC *gc;
3369       GdkColor col;
3370
3371       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3372         {
3373           if (tree_view->priv->drag_highlight_window)
3374             {
3375               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3376                                         NULL);
3377               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3378             }
3379
3380           attributes.window_type = GDK_WINDOW_CHILD;
3381           attributes.wclass = GDK_INPUT_OUTPUT;
3382           attributes.x = tree_view->priv->drag_column_x;
3383           attributes.y = 0;
3384           width = attributes.width = tree_view->priv->drag_column->button->allocation.width;
3385           height = attributes.height = tree_view->priv->drag_column->button->allocation.height;
3386           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3387           attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
3388           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3389           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
3390           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3391           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3392
3393           mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width, height, 1);
3394           gc = gdk_gc_new (mask);
3395           col.pixel = 1;
3396           gdk_gc_set_foreground (gc, &col);
3397           gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
3398           col.pixel = 0;
3399           gdk_gc_set_foreground(gc, &col);
3400           gdk_draw_rectangle (mask, gc, TRUE, 2, 2, width - 4, height - 4);
3401           g_object_unref (gc);
3402
3403           gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
3404                                          mask, 0, 0);
3405           if (mask) g_object_unref (mask);
3406           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3407         }
3408     }
3409   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3410     {
3411       gint i, j = 1;
3412       GdkGC *gc;
3413       GdkColor col;
3414
3415       width = tree_view->priv->expander_size;
3416
3417       /* Get x, y, width, height of arrow */
3418       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3419       if (reorder->left_column)
3420         {
3421           x += reorder->left_column->button->allocation.x + reorder->left_column->button->allocation.width - width/2;
3422           height = reorder->left_column->button->allocation.height;
3423         }
3424       else
3425         {
3426           x += reorder->right_column->button->allocation.x - width/2;
3427           height = reorder->right_column->button->allocation.height;
3428         }
3429       y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */
3430       height += tree_view->priv->expander_size;
3431
3432       /* Create the new window */
3433       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3434         {
3435           if (tree_view->priv->drag_highlight_window)
3436             {
3437               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3438                                         NULL);
3439               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3440             }
3441
3442           attributes.window_type = GDK_WINDOW_TEMP;
3443           attributes.wclass = GDK_INPUT_OUTPUT;
3444           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3445           attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
3446           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3447           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
3448           attributes.x = x;
3449           attributes.y = y;
3450           attributes.width = width;
3451           attributes.height = height;
3452           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3453                                                                    &attributes, attributes_mask);
3454           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3455
3456           mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width, height, 1);
3457           gc = gdk_gc_new (mask);
3458           col.pixel = 1;
3459           gdk_gc_set_foreground (gc, &col);
3460           gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
3461
3462           /* Draw the 2 arrows as per above */
3463           col.pixel = 0;
3464           gdk_gc_set_foreground (gc, &col);
3465           for (i = 0; i < width; i ++)
3466             {
3467               if (i == (width/2 - 1))
3468                 continue;
3469               gdk_draw_line (mask, gc, i, j, i, height - j);
3470               if (i < (width/2 - 1))
3471                 j++;
3472               else
3473                 j--;
3474             }
3475           g_object_unref (gc);
3476           gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
3477                                          mask, 0, 0);
3478           if (mask) g_object_unref (mask);
3479         }
3480
3481       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3482       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3483     }
3484   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3485            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3486     {
3487       gint i, j = 1;
3488       GdkGC *gc;
3489       GdkColor col;
3490
3491       width = tree_view->priv->expander_size;
3492
3493       /* Get x, y, width, height of arrow */
3494       width = width/2; /* remember, the arrow only takes half the available width */
3495       gdk_window_get_origin (widget->window, &x, &y);
3496       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3497         x += widget->allocation.width - width;
3498
3499       if (reorder->left_column)
3500         height = reorder->left_column->button->allocation.height;
3501       else
3502         height = reorder->right_column->button->allocation.height;
3503
3504       y -= tree_view->priv->expander_size;
3505       height += 2*tree_view->priv->expander_size;
3506
3507       /* Create the new window */
3508       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3509           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3510         {
3511           if (tree_view->priv->drag_highlight_window)
3512             {
3513               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3514                                         NULL);
3515               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3516             }
3517
3518           attributes.window_type = GDK_WINDOW_TEMP;
3519           attributes.wclass = GDK_INPUT_OUTPUT;
3520           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3521           attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
3522           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3523           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
3524           attributes.x = x;
3525           attributes.y = y;
3526           attributes.width = width;
3527           attributes.height = height;
3528           tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
3529           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3530
3531           mask = gdk_pixmap_new (tree_view->priv->drag_highlight_window, width, height, 1);
3532           gc = gdk_gc_new (mask);
3533           col.pixel = 1;
3534           gdk_gc_set_foreground (gc, &col);
3535           gdk_draw_rectangle (mask, gc, TRUE, 0, 0, width, height);
3536
3537           /* Draw the 2 arrows as per above */
3538           col.pixel = 0;
3539           gdk_gc_set_foreground (gc, &col);
3540           j = tree_view->priv->expander_size;
3541           for (i = 0; i < width; i ++)
3542             {
3543               gint k;
3544               if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3545                 k = width - i - 1;
3546               else
3547                 k = i;
3548               gdk_draw_line (mask, gc, k, j, k, height - j);
3549               gdk_draw_line (mask, gc, k, 0, k, tree_view->priv->expander_size - j);
3550               gdk_draw_line (mask, gc, k, height, k, height - tree_view->priv->expander_size + j);
3551               j--;
3552             }
3553           g_object_unref (gc);
3554           gdk_window_shape_combine_mask (tree_view->priv->drag_highlight_window,
3555                                          mask, 0, 0);
3556           if (mask) g_object_unref (mask);
3557         }
3558
3559       tree_view->priv->drag_column_window_state = arrow_type;
3560       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3561    }
3562   else
3563     {
3564       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
3565       gdk_window_hide (tree_view->priv->drag_highlight_window);
3566       return;
3567     }
3568
3569   gdk_window_show (tree_view->priv->drag_highlight_window);
3570   gdk_window_raise (tree_view->priv->drag_highlight_window);
3571 }
3572
3573 static gboolean
3574 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
3575                                     GdkEventMotion *event)
3576 {
3577   gint x;
3578   gint new_width;
3579   GtkTreeViewColumn *column;
3580   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3581
3582   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
3583
3584   if (event->is_hint || event->window != widget->window)
3585     gtk_widget_get_pointer (widget, &x, NULL);
3586   else
3587     x = event->x;
3588
3589   if (tree_view->priv->hadjustment)
3590     x += tree_view->priv->hadjustment->value;
3591
3592   new_width = gtk_tree_view_new_column_width (tree_view,
3593                                               tree_view->priv->drag_pos, &x);
3594   if (x != tree_view->priv->x_drag &&
3595       (new_width != column->fixed_width))
3596     {
3597       column->use_resized_width = TRUE;
3598       column->resized_width = new_width;
3599       if (column->expand)
3600         column->resized_width -= tree_view->priv->last_extra_space_per_column;
3601       gtk_widget_queue_resize (widget);
3602     }
3603
3604   return FALSE;
3605 }
3606
3607
3608 static void
3609 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view)
3610 {
3611   GtkTreeViewColumnReorder *reorder = NULL;
3612   GList *list;
3613   gint mouse_x;
3614
3615   gdk_window_get_pointer (tree_view->priv->header_window, &mouse_x, NULL, NULL);
3616   for (list = tree_view->priv->column_drag_info; list; list = list->next)
3617     {
3618       reorder = (GtkTreeViewColumnReorder *) list->data;
3619       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
3620         break;
3621       reorder = NULL;
3622     }
3623
3624   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
3625       return;*/
3626
3627   tree_view->priv->cur_reorder = reorder;
3628   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
3629 }
3630
3631 static void
3632 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
3633 {
3634   GdkRectangle visible_rect;
3635   gint y;
3636   gint offset;
3637   gfloat value;
3638
3639   gdk_window_get_pointer (tree_view->priv->bin_window, NULL, &y, NULL);
3640   y += tree_view->priv->dy;
3641
3642   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3643
3644   /* see if we are near the edge. */
3645   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
3646   if (offset > 0)
3647     {
3648       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
3649       if (offset < 0)
3650         return;
3651     }
3652
3653   value = CLAMP (tree_view->priv->vadjustment->value + offset, 0.0,
3654                  tree_view->priv->vadjustment->upper - tree_view->priv->vadjustment->page_size);
3655   gtk_adjustment_set_value (tree_view->priv->vadjustment, value);
3656 }
3657
3658 static gboolean
3659 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view)
3660 {
3661   GdkRectangle visible_rect;
3662   gint x;
3663   gint offset;
3664   gfloat value;
3665
3666   gdk_window_get_pointer (tree_view->priv->bin_window, &x, NULL, NULL);
3667
3668   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3669
3670   /* See if we are near the edge. */
3671   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
3672   if (offset > 0)
3673     {
3674       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
3675       if (offset < 0)
3676         return TRUE;
3677     }
3678   offset = offset/3;
3679
3680   value = CLAMP (tree_view->priv->hadjustment->value + offset,
3681                  0.0, tree_view->priv->hadjustment->upper - tree_view->priv->hadjustment->page_size);
3682   gtk_adjustment_set_value (tree_view->priv->hadjustment, value);
3683
3684   return TRUE;
3685
3686 }
3687
3688 static gboolean
3689 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
3690                                   GdkEventMotion *event)
3691 {
3692   GtkTreeView *tree_view = (GtkTreeView *) widget;
3693   GtkTreeViewColumn *column = tree_view->priv->drag_column;
3694   gint x, y;
3695
3696   /* Sanity Check */
3697   if ((column == NULL) ||
3698       (event->window != tree_view->priv->drag_window))
3699     return FALSE;
3700
3701   /* Handle moving the header */
3702   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
3703   x = CLAMP (x + (gint)event->x - column->drag_x, 0,
3704              MAX (tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width) - column->button->allocation.width);
3705   gdk_window_move (tree_view->priv->drag_window, x, y);
3706
3707   /* autoscroll, if needed */
3708   gtk_tree_view_horizontal_autoscroll (tree_view);
3709   /* Update the current reorder position and arrow; */
3710   gtk_tree_view_update_current_reorder (tree_view);
3711
3712   return TRUE;
3713 }
3714
3715 static void
3716 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
3717 {
3718   remove_scroll_timeout (tree_view);
3719   gtk_grab_remove (GTK_WIDGET (tree_view));
3720
3721   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
3722     {
3723       GtkTreePath *tmp_path;
3724
3725       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
3726
3727       /* The anchor path should be set to the start path */
3728       tmp_path = _gtk_tree_view_find_path (tree_view,
3729                                            tree_view->priv->rubber_band_start_tree,
3730                                            tree_view->priv->rubber_band_start_node);
3731
3732       if (tree_view->priv->anchor)
3733         gtk_tree_row_reference_free (tree_view->priv->anchor);
3734
3735       tree_view->priv->anchor =
3736         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
3737                                           tree_view->priv->model,
3738                                           tmp_path);
3739
3740       gtk_tree_path_free (tmp_path);
3741
3742       /* ... and the cursor to the end path */
3743       tmp_path = _gtk_tree_view_find_path (tree_view,
3744                                            tree_view->priv->rubber_band_end_tree,
3745                                            tree_view->priv->rubber_band_end_node);
3746       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, FALSE, FALSE);
3747       gtk_tree_path_free (tmp_path);
3748
3749       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
3750     }
3751
3752   /* Clear status variables */
3753   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
3754   tree_view->priv->rubber_band_shift = 0;
3755   tree_view->priv->rubber_band_ctrl = 0;
3756
3757   tree_view->priv->rubber_band_start_node = NULL;
3758   tree_view->priv->rubber_band_start_tree = NULL;
3759   tree_view->priv->rubber_band_end_node = NULL;
3760   tree_view->priv->rubber_band_end_tree = NULL;
3761 }
3762
3763 static void
3764 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
3765                                                  GtkRBTree   *start_tree,
3766                                                  GtkRBNode   *start_node,
3767                                                  GtkRBTree   *end_tree,
3768                                                  GtkRBNode   *end_node,
3769                                                  gboolean     select,
3770                                                  gboolean     skip_start,
3771                                                  gboolean     skip_end)
3772 {
3773   if (start_node == end_node)
3774     return;
3775
3776   /* We skip the first node and jump inside the loop */
3777   if (skip_start)
3778     goto skip_first;
3779
3780   do
3781     {
3782       /* Small optimization by assuming insensitive nodes are never
3783        * selected.
3784        */
3785       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
3786         {
3787           GtkTreePath *path;
3788           gboolean selectable;
3789
3790           path = _gtk_tree_view_find_path (tree_view, start_tree, start_node);
3791           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
3792           gtk_tree_path_free (path);
3793
3794           if (!selectable)
3795             goto node_not_selectable;
3796         }
3797
3798       if (select)
3799         {
3800           if (tree_view->priv->rubber_band_shift)
3801             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3802           else if (tree_view->priv->rubber_band_ctrl)
3803             {
3804               /* Toggle the selection state */
3805               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
3806                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3807               else
3808                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3809             }
3810           else
3811             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3812         }
3813       else
3814         {
3815           /* Mirror the above */
3816           if (tree_view->priv->rubber_band_shift)
3817             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3818           else if (tree_view->priv->rubber_band_ctrl)
3819             {
3820               /* Toggle the selection state */
3821               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
3822                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3823               else
3824                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3825             }
3826           else
3827             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3828         }
3829
3830       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
3831
3832 node_not_selectable:
3833       if (start_node == end_node)
3834         break;
3835
3836 skip_first:
3837
3838       if (start_node->children)
3839         {
3840           start_tree = start_node->children;
3841           start_node = start_tree->root;
3842           while (start_node->left != start_tree->nil)
3843             start_node = start_node->left;
3844         }
3845       else
3846         {
3847           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
3848
3849           if (!start_tree)
3850             /* Ran out of tree */
3851             break;
3852         }
3853
3854       if (skip_end && start_node == end_node)
3855         break;
3856     }
3857   while (TRUE);
3858 }
3859
3860 static void
3861 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
3862 {
3863   GtkRBTree *start_tree, *end_tree;
3864   GtkRBNode *start_node, *end_node;
3865
3866   _gtk_rbtree_find_offset (tree_view->priv->tree, MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &start_tree, &start_node);
3867   _gtk_rbtree_find_offset (tree_view->priv->tree, MAX (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &end_tree, &end_node);
3868
3869   /* Handle the start area first */
3870   if (!tree_view->priv->rubber_band_start_node)
3871     {
3872       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3873                                                        start_tree,
3874                                                        start_node,
3875                                                        end_tree,
3876                                                        end_node,
3877                                                        TRUE,
3878                                                        FALSE,
3879                                                        FALSE);
3880     }
3881   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
3882            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
3883     {
3884       /* New node is above the old one; selection became bigger */
3885       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3886                                                        start_tree,
3887                                                        start_node,
3888                                                        tree_view->priv->rubber_band_start_tree,
3889                                                        tree_view->priv->rubber_band_start_node,
3890                                                        TRUE,
3891                                                        FALSE,
3892                                                        TRUE);
3893     }
3894   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
3895            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
3896     {
3897       /* New node is below the old one; selection became smaller */
3898       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3899                                                        tree_view->priv->rubber_band_start_tree,
3900                                                        tree_view->priv->rubber_band_start_node,
3901                                                        start_tree,
3902                                                        start_node,
3903                                                        FALSE,
3904                                                        FALSE,
3905                                                        TRUE);
3906     }
3907
3908   tree_view->priv->rubber_band_start_tree = start_tree;
3909   tree_view->priv->rubber_band_start_node = start_node;
3910
3911   /* Next, handle the end area */
3912   if (!tree_view->priv->rubber_band_end_node)
3913     {
3914       /* In the event this happens, start_node was also NULL; this case is
3915        * handled above.
3916        */
3917     }
3918   else if (!end_node)
3919     {
3920       /* Find the last node in the tree */
3921       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
3922                                &end_tree, &end_node);
3923
3924       /* Selection reached end of the tree */
3925       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3926                                                        tree_view->priv->rubber_band_end_tree,
3927                                                        tree_view->priv->rubber_band_end_node,
3928                                                        end_tree,
3929                                                        end_node,
3930                                                        TRUE,
3931                                                        TRUE,
3932                                                        FALSE);
3933     }
3934   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
3935            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
3936     {
3937       /* New node is below the old one; selection became bigger */
3938       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3939                                                        tree_view->priv->rubber_band_end_tree,
3940                                                        tree_view->priv->rubber_band_end_node,
3941                                                        end_tree,
3942                                                        end_node,
3943                                                        TRUE,
3944                                                        TRUE,
3945                                                        FALSE);
3946     }
3947   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
3948            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
3949     {
3950       /* New node is above the old one; selection became smaller */
3951       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3952                                                        end_tree,
3953                                                        end_node,
3954                                                        tree_view->priv->rubber_band_end_tree,
3955                                                        tree_view->priv->rubber_band_end_node,
3956                                                        FALSE,
3957                                                        TRUE,
3958                                                        FALSE);
3959     }
3960
3961   tree_view->priv->rubber_band_end_tree = end_tree;
3962   tree_view->priv->rubber_band_end_node = end_node;
3963 }
3964
3965 static void
3966 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
3967 {
3968   gint x, y;
3969   GdkRectangle old_area;
3970   GdkRectangle new_area;
3971   GdkRectangle common;
3972   GdkRegion *invalid_region;
3973
3974   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
3975   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
3976   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
3977   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
3978
3979   gdk_window_get_pointer (tree_view->priv->bin_window, &x, &y, NULL);
3980
3981   x = MAX (x, 0);
3982   y = MAX (y, 0) + tree_view->priv->dy;
3983
3984   new_area.x = MIN (tree_view->priv->press_start_x, x);
3985   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
3986   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
3987   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
3988
3989   invalid_region = gdk_region_rectangle (&old_area);
3990   gdk_region_union_with_rect (invalid_region, &new_area);
3991
3992   gdk_rectangle_intersect (&old_area, &new_area, &common);
3993   if (common.width > 2 && common.height > 2)
3994     {
3995       GdkRegion *common_region;
3996
3997       /* make sure the border is invalidated */
3998       common.x += 1;
3999       common.y += 1;
4000       common.width -= 2;
4001       common.height -= 2;
4002
4003       common_region = gdk_region_rectangle (&common);
4004
4005       gdk_region_subtract (invalid_region, common_region);
4006       gdk_region_destroy (common_region);
4007     }
4008
4009   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
4010
4011   gdk_region_destroy (invalid_region);
4012
4013   tree_view->priv->rubber_band_x = x;
4014   tree_view->priv->rubber_band_y = y;
4015
4016   gtk_tree_view_update_rubber_band_selection (tree_view);
4017 }
4018
4019 static void
4020 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4021                                 GdkRectangle *area)
4022 {
4023   cairo_t *cr;
4024   GdkRectangle rect;
4025   GdkRectangle rubber_rect;
4026
4027   rubber_rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4028   rubber_rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4029   rubber_rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4030   rubber_rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4031
4032   if (!gdk_rectangle_intersect (&rubber_rect, area, &rect))
4033     return;
4034
4035   cr = gdk_cairo_create (tree_view->priv->bin_window);
4036   cairo_set_line_width (cr, 1.0);
4037
4038   cairo_set_source_rgba (cr,
4039                          GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].red / 65535.,
4040                          GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].green / 65535.,
4041                          GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].blue / 65535.,
4042                          .25);
4043
4044   gdk_cairo_rectangle (cr, &rect);
4045   cairo_clip (cr);
4046   cairo_paint (cr);
4047
4048   cairo_set_source_rgb (cr,
4049                         GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].red / 65535.,
4050                         GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].green / 65535.,
4051                         GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].blue / 65535.);
4052
4053   cairo_rectangle (cr,
4054                    rubber_rect.x + 0.5, rubber_rect.y + 0.5,
4055                    rubber_rect.width - 1, rubber_rect.height - 1);
4056   cairo_stroke (cr);
4057
4058   cairo_destroy (cr);
4059 }
4060
4061 static gboolean
4062 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4063                                  GdkEventMotion *event)
4064 {
4065   GtkTreeView *tree_view;
4066   GtkRBTree *tree;
4067   GtkRBNode *node;
4068   gint new_y;
4069
4070   tree_view = (GtkTreeView *) widget;
4071
4072   if (tree_view->priv->tree == NULL)
4073     return FALSE;
4074
4075   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4076     {
4077       gtk_grab_add (GTK_WIDGET (tree_view));
4078       gtk_tree_view_update_rubber_band (tree_view);
4079
4080       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4081     }
4082   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4083     {
4084       gtk_tree_view_update_rubber_band (tree_view);
4085
4086       add_scroll_timeout (tree_view);
4087     }
4088
4089   /* only check for an initiated drag when a button is pressed */
4090   if (tree_view->priv->pressed_button >= 0
4091       && !tree_view->priv->rubber_band_status)
4092     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4093
4094   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4095   if (new_y < 0)
4096     new_y = 0;
4097
4098   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4099
4100   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4101   if ((tree_view->priv->button_pressed_node != NULL) &&
4102       (tree_view->priv->button_pressed_node != node))
4103     node = NULL;
4104
4105   prelight_or_select (tree_view, tree, node, event->x, event->y);
4106
4107   return TRUE;
4108 }
4109
4110 static gboolean
4111 gtk_tree_view_motion (GtkWidget      *widget,
4112                       GdkEventMotion *event)
4113 {
4114   GtkTreeView *tree_view;
4115
4116   tree_view = (GtkTreeView *) widget;
4117
4118   /* Resizing a column */
4119   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
4120     return gtk_tree_view_motion_resize_column (widget, event);
4121
4122   /* Drag column */
4123   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
4124     return gtk_tree_view_motion_drag_column (widget, event);
4125
4126   /* Sanity check it */
4127   if (event->window == tree_view->priv->bin_window)
4128     return gtk_tree_view_motion_bin_window (widget, event);
4129
4130   return FALSE;
4131 }
4132
4133 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4134  * the tree is empty.
4135  */
4136 static void
4137 invalidate_empty_focus (GtkTreeView *tree_view)
4138 {
4139   GdkRectangle area;
4140
4141   if (!GTK_WIDGET_HAS_FOCUS (tree_view))
4142     return;
4143
4144   area.x = 0;
4145   area.y = 0;
4146   gdk_drawable_get_size (tree_view->priv->bin_window, &area.width, &area.height);
4147   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4148 }
4149
4150 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4151  * is empty.
4152  */
4153 static void
4154 draw_empty_focus (GtkTreeView *tree_view, GdkRectangle *clip_area)
4155 {
4156   gint w, h;
4157
4158   if (!GTK_WIDGET_HAS_FOCUS (tree_view))
4159     return;
4160
4161   gdk_drawable_get_size (tree_view->priv->bin_window, &w, &h);
4162
4163   w -= 2;
4164   h -= 2;
4165
4166   if (w > 0 && h > 0)
4167     gtk_paint_focus (GTK_WIDGET (tree_view)->style,
4168                      tree_view->priv->bin_window,
4169                      GTK_WIDGET_STATE (tree_view),
4170                      clip_area,
4171                      GTK_WIDGET (tree_view),
4172                      NULL,
4173                      1, 1, w, h);
4174 }
4175
4176 static void
4177 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4178                                GdkEventExpose *event,
4179                                gint            n_visible_columns)
4180 {
4181   GList *list = tree_view->priv->columns;
4182   gint i = 0;
4183   gint current_x = 0;
4184
4185   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4186       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4187     return;
4188
4189   /* Only draw the lines for visible rows and columns */
4190   for (list = tree_view->priv->columns; list; list = list->next, i++)
4191     {
4192       GtkTreeViewColumn *column = list->data;
4193
4194       /* We don't want a line for the last column */
4195       if (i == n_visible_columns - 1)
4196         break;
4197
4198       if (! column->visible)
4199         continue;
4200
4201       current_x += column->width;
4202
4203       gdk_draw_line (event->window,
4204                      tree_view->priv->grid_line_gc,
4205                      current_x - 1, 0,
4206                      current_x - 1, tree_view->priv->height);
4207     }
4208 }
4209
4210 /* Warning: Very scary function.
4211  * Modify at your own risk
4212  *
4213  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4214  * FIXME: It's not...
4215  */
4216 static gboolean
4217 gtk_tree_view_bin_expose (GtkWidget      *widget,
4218                           GdkEventExpose *event)
4219 {
4220   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4221   GtkTreePath *path;
4222   GtkRBTree *tree;
4223   GList *list;
4224   GtkRBNode *node;
4225   GtkRBNode *cursor = NULL;
4226   GtkRBTree *cursor_tree = NULL;
4227   GtkRBNode *drag_highlight = NULL;
4228   GtkRBTree *drag_highlight_tree = NULL;
4229   GtkTreeIter iter;
4230   gint new_y;
4231   gint y_offset, cell_offset;
4232   gint max_height;
4233   gint depth;
4234   GdkRectangle background_area;
4235   GdkRectangle cell_area;
4236   guint flags;
4237   gint highlight_x;
4238   gint expander_cell_width;
4239   gint bin_window_width;
4240   gint bin_window_height;
4241   GtkTreePath *cursor_path;
4242   GtkTreePath *drag_dest_path;
4243   GList *first_column, *last_column;
4244   gint vertical_separator;
4245   gint horizontal_separator;
4246   gint focus_line_width;
4247   gboolean allow_rules;
4248   gboolean has_special_cell;
4249   gboolean rtl;
4250   gint n_visible_columns;
4251   gint pointer_x, pointer_y;
4252   gint grid_line_width;
4253   gboolean got_pointer = FALSE;
4254   gboolean row_ending_details;
4255   gboolean draw_vgrid_lines, draw_hgrid_lines;
4256
4257   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4258
4259   gtk_widget_style_get (widget,
4260                         "horizontal-separator", &horizontal_separator,
4261                         "vertical-separator", &vertical_separator,
4262                         "allow-rules", &allow_rules,
4263                         "focus-line-width", &focus_line_width,
4264                         "row-ending-details", &row_ending_details,
4265                         NULL);
4266
4267   if (tree_view->priv->tree == NULL)
4268     {
4269       draw_empty_focus (tree_view, &event->area);
4270       return TRUE;
4271     }
4272
4273   /* clip event->area to the visible area */
4274   if (event->area.height < 0)
4275     return TRUE;
4276
4277   validate_visible_area (tree_view);
4278
4279   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, event->area.y);
4280
4281   if (new_y < 0)
4282     new_y = 0;
4283   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4284   gdk_drawable_get_size (tree_view->priv->bin_window,
4285                          &bin_window_width, &bin_window_height);
4286
4287   if (tree_view->priv->height < bin_window_height)
4288     {
4289       gtk_paint_flat_box (widget->style,
4290                           event->window,
4291                           widget->state,
4292                           GTK_SHADOW_NONE,
4293                           &event->area,
4294                           widget,
4295                           "cell_even",
4296                           0, tree_view->priv->height,
4297                           bin_window_width,
4298                           bin_window_height - tree_view->priv->height);
4299     }
4300
4301   if (node == NULL)
4302     return TRUE;
4303
4304   /* find the path for the node */
4305   path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
4306                                    tree,
4307                                    node);
4308   gtk_tree_model_get_iter (tree_view->priv->model,
4309                            &iter,
4310                            path);
4311   depth = gtk_tree_path_get_depth (path);
4312   gtk_tree_path_free (path);
4313
4314   cursor_path = NULL;
4315   drag_dest_path = NULL;
4316
4317   if (tree_view->priv->cursor)
4318     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
4319
4320   if (cursor_path)
4321     _gtk_tree_view_find_node (tree_view, cursor_path,
4322                               &cursor_tree, &cursor);
4323
4324   if (tree_view->priv->drag_dest_row)
4325     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4326
4327   if (drag_dest_path)
4328     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4329                               &drag_highlight_tree, &drag_highlight);
4330
4331   draw_vgrid_lines =
4332     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4333     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4334   draw_hgrid_lines =
4335     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4336     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4337
4338   if (draw_vgrid_lines || draw_hgrid_lines)
4339     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4340
4341   n_visible_columns = 0;
4342   for (list = tree_view->priv->columns; list; list = list->next)
4343     {
4344       if (! GTK_TREE_VIEW_COLUMN (list->data)->visible)
4345         continue;
4346       n_visible_columns ++;
4347     }
4348
4349   /* Find the last column */
4350   for (last_column = g_list_last (tree_view->priv->columns);
4351        last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible);
4352        last_column = last_column->prev)
4353     ;
4354
4355   /* and the first */
4356   for (first_column = g_list_first (tree_view->priv->columns);
4357        first_column && !(GTK_TREE_VIEW_COLUMN (first_column->data)->visible);
4358        first_column = first_column->next)
4359     ;
4360
4361   /* Actually process the expose event.  To do this, we want to
4362    * start at the first node of the event, and walk the tree in
4363    * order, drawing each successive node.
4364    */
4365
4366   do
4367     {
4368       gboolean parity;
4369       gboolean is_separator = FALSE;
4370       gboolean is_first = FALSE;
4371       gboolean is_last = FALSE;
4372
4373       is_separator = row_is_separator (tree_view, &iter, NULL);
4374
4375       max_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
4376
4377       cell_offset = 0;
4378       highlight_x = 0; /* should match x coord of first cell */
4379       expander_cell_width = 0;
4380
4381       background_area.y = y_offset + event->area.y;
4382       background_area.height = max_height;
4383
4384       flags = 0;
4385
4386       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4387         flags |= GTK_CELL_RENDERER_PRELIT;
4388
4389       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4390         flags |= GTK_CELL_RENDERER_SELECTED;
4391
4392       parity = _gtk_rbtree_node_find_parity (tree, node);
4393
4394       /* we *need* to set cell data on all cells before the call
4395        * to _has_special_cell, else _has_special_cell() does not
4396        * return a correct value.
4397        */
4398       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4399            list;
4400            list = (rtl ? list->prev : list->next))
4401         {
4402           GtkTreeViewColumn *column = list->data;
4403           gtk_tree_view_column_cell_set_cell_data (column,
4404                                                    tree_view->priv->model,
4405                                                    &iter,
4406                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4407                                                    node->children?TRUE:FALSE);
4408         }
4409
4410       has_special_cell = gtk_tree_view_has_special_cell (tree_view);
4411
4412       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4413            list;
4414            list = (rtl ? list->prev : list->next))
4415         {
4416           GtkTreeViewColumn *column = list->data;
4417           const gchar *detail = NULL;
4418           GtkStateType state;
4419
4420           if (!column->visible)
4421             continue;
4422
4423           if (cell_offset > event->area.x + event->area.width ||
4424               cell_offset + column->width < event->area.x)
4425             {
4426               cell_offset += column->width;
4427               continue;
4428             }
4429
4430           if (column->show_sort_indicator)
4431             flags |= GTK_CELL_RENDERER_SORTED;
4432           else
4433             flags &= ~GTK_CELL_RENDERER_SORTED;
4434
4435           if (cursor == node)
4436             flags |= GTK_CELL_RENDERER_FOCUSED;
4437           else
4438             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4439
4440           background_area.x = cell_offset;
4441           background_area.width = column->width;
4442
4443           cell_area = background_area;
4444           cell_area.y += vertical_separator / 2;
4445           cell_area.x += horizontal_separator / 2;
4446           cell_area.height -= vertical_separator;
4447           cell_area.width -= horizontal_separator;
4448
4449           if (draw_vgrid_lines)
4450             {
4451               if (list == first_column)
4452                 {
4453                   cell_area.width -= grid_line_width / 2;
4454                 }
4455               else if (list == last_column)
4456                 {
4457                   cell_area.x += grid_line_width / 2;
4458                   cell_area.width -= grid_line_width / 2;
4459                 }
4460               else
4461                 {
4462                   cell_area.x += grid_line_width / 2;
4463                   cell_area.width -= grid_line_width;
4464                 }
4465             }
4466
4467           if (draw_hgrid_lines)
4468             {
4469               cell_area.y += grid_line_width / 2;
4470               cell_area.height -= grid_line_width;
4471             }
4472
4473           if (gdk_region_rect_in (event->region, &background_area) == GDK_OVERLAP_RECTANGLE_OUT)
4474             {
4475               cell_offset += column->width;
4476               continue;
4477             }
4478
4479           gtk_tree_view_column_cell_set_cell_data (column,
4480                                                    tree_view->priv->model,
4481                                                    &iter,
4482                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4483                                                    node->children?TRUE:FALSE);
4484
4485           /* Select the detail for drawing the cell.  relevant
4486            * factors are parity, sortedness, and whether to
4487            * display rules.
4488            */
4489           if (allow_rules && tree_view->priv->has_rules)
4490             {
4491               if ((flags & GTK_CELL_RENDERER_SORTED) &&
4492                   n_visible_columns >= 3)
4493                 {
4494                   if (parity)
4495                     detail = "cell_odd_ruled_sorted";
4496                   else
4497                     detail = "cell_even_ruled_sorted";
4498                 }
4499               else
4500                 {
4501                   if (parity)
4502                     detail = "cell_odd_ruled";
4503                   else
4504                     detail = "cell_even_ruled";
4505                 }
4506             }
4507           else
4508             {
4509               if ((flags & GTK_CELL_RENDERER_SORTED) &&
4510                   n_visible_columns >= 3)
4511                 {
4512                   if (parity)
4513                     detail = "cell_odd_sorted";
4514                   else
4515                     detail = "cell_even_sorted";
4516                 }
4517               else
4518                 {
4519                   if (parity)
4520                     detail = "cell_odd";
4521                   else
4522                     detail = "cell_even";
4523                 }
4524             }
4525
4526           g_assert (detail);
4527
4528           if (widget->state == GTK_STATE_INSENSITIVE)
4529             state = GTK_STATE_INSENSITIVE;
4530           else if (flags & GTK_CELL_RENDERER_SELECTED)
4531             state = GTK_STATE_SELECTED;
4532           else
4533             state = GTK_STATE_NORMAL;
4534
4535           /* Draw background */
4536           if (row_ending_details)
4537             {
4538               char new_detail[128];
4539
4540               is_first = (rtl ? !list->next : !list->prev);
4541               is_last = (rtl ? !list->prev : !list->next);
4542
4543               /* (I don't like the snprintfs either, but couldn't find a
4544                * less messy way).
4545                */
4546               if (is_first && is_last)
4547                 g_snprintf (new_detail, 127, "%s", detail);
4548               else if (is_first)
4549                 g_snprintf (new_detail, 127, "%s_start", detail);
4550               else if (is_last)
4551                 g_snprintf (new_detail, 127, "%s_end", detail);
4552               else
4553                 g_snprintf (new_detail, 128, "%s_middle", detail);
4554
4555               gtk_paint_flat_box (widget->style,
4556                                   event->window,
4557                                   state,
4558                                   GTK_SHADOW_NONE,
4559                                   &event->area,
4560                                   widget,
4561                                   new_detail,
4562                                   background_area.x,
4563                                   background_area.y,
4564                                   background_area.width,
4565                                   background_area.height);
4566             }
4567           else
4568             {
4569               gtk_paint_flat_box (widget->style,
4570                                   event->window,
4571                                   state,
4572                                   GTK_SHADOW_NONE,
4573                                   &event->area,
4574                                   widget,
4575                                   detail,
4576                                   background_area.x,
4577                                   background_area.y,
4578                                   background_area.width,
4579                                   background_area.height);
4580             }
4581
4582           if (draw_hgrid_lines)
4583             {
4584               if (background_area.y > 0)
4585                 gdk_draw_line (event->window,
4586                                tree_view->priv->grid_line_gc,
4587                                background_area.x, background_area.y,
4588                                background_area.x + background_area.width,
4589                                background_area.y);
4590
4591               if (y_offset + max_height >= event->area.height)
4592                 gdk_draw_line (event->window,
4593                                tree_view->priv->grid_line_gc,
4594                                background_area.x, background_area.y + max_height,
4595                                background_area.x + background_area.width,
4596                                background_area.y + max_height);
4597             }
4598
4599           if (gtk_tree_view_is_expander_column (tree_view, column))
4600             {
4601               if (!rtl)
4602                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
4603               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
4604
4605               if (TREE_VIEW_DRAW_EXPANDERS(tree_view))
4606                 {
4607                   if (!rtl)
4608                     cell_area.x += depth * tree_view->priv->expander_size;
4609                   cell_area.width -= depth * tree_view->priv->expander_size;
4610                 }
4611
4612               /* If we have an expander column, the highlight underline
4613                * starts with that column, so that it indicates which
4614                * level of the tree we're dropping at.
4615                */
4616               highlight_x = cell_area.x;
4617               expander_cell_width = cell_area.width;
4618
4619               if (is_separator)
4620                 gtk_paint_hline (widget->style,
4621                                  event->window,
4622                                  state,
4623                                  &cell_area,
4624                                  widget,
4625                                  NULL,
4626                                  cell_area.x,
4627                                  cell_area.x + cell_area.width,
4628                                  cell_area.y + cell_area.height / 2);
4629               else
4630                 _gtk_tree_view_column_cell_render (column,
4631                                                    event->window,
4632                                                    &background_area,
4633                                                    &cell_area,
4634                                                    &event->area,
4635                                                    flags);
4636               if (TREE_VIEW_DRAW_EXPANDERS(tree_view)
4637                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
4638                 {
4639                   if (!got_pointer)
4640                     {
4641                       gdk_window_get_pointer (tree_view->priv->bin_window,
4642                                               &pointer_x, &pointer_y, NULL);
4643                       got_pointer = TRUE;
4644                     }
4645
4646                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
4647                                             tree,
4648                                             node,
4649                                             pointer_x, pointer_y);
4650                 }
4651             }
4652           else
4653             {
4654               if (is_separator)
4655                 gtk_paint_hline (widget->style,
4656                                  event->window,
4657                                  state,
4658                                  &cell_area,
4659                                  widget,
4660                                  NULL,
4661                                  cell_area.x,
4662                                  cell_area.x + cell_area.width,
4663                                  cell_area.y + cell_area.height / 2);
4664               else
4665                 _gtk_tree_view_column_cell_render (column,
4666                                                    event->window,
4667                                                    &background_area,
4668                                                    &cell_area,
4669                                                    &event->area,
4670                                                    flags);
4671             }
4672
4673           if (gtk_tree_view_is_expander_column (tree_view, column) &&
4674               tree_view->priv->tree_lines_enabled)
4675             {
4676               gint x = background_area.x;
4677               gint mult = rtl ? -1 : 1;
4678               gint y0 = background_area.y;
4679               gint y1 = background_area.y + background_area.height/2;
4680               gint y2 = background_area.y + background_area.height;
4681
4682               if (rtl)
4683                 x += background_area.width - 1;
4684
4685               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
4686                   && depth > 1)
4687                 {
4688                   gdk_draw_line (event->window,
4689                                  tree_view->priv->tree_line_gc,
4690                                  x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4691                                  y1,
4692                                  x + tree_view->priv->expander_size * (depth - 1.1) * mult,
4693                                  y1);
4694                 }
4695               else if (depth > 1)
4696                 {
4697                   gdk_draw_line (event->window,
4698                                  tree_view->priv->tree_line_gc,
4699                                  x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4700                                  y1,
4701                                  x + tree_view->priv->expander_size * (depth - 0.5) * mult,
4702                                  y1);
4703                 }
4704
4705               if (depth > 1)
4706                 {
4707                   gint i;
4708                   GtkRBNode *tmp_node;
4709                   GtkRBTree *tmp_tree;
4710
4711                   if (!_gtk_rbtree_next (tree, node))
4712                     gdk_draw_line (event->window,
4713                                    tree_view->priv->tree_line_gc,
4714                                    x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4715                                    y0,
4716                                    x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4717                                    y1);
4718                   else
4719                     gdk_draw_line (event->window,
4720                                    tree_view->priv->tree_line_gc,
4721                                    x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4722                                    y0,
4723                                    x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4724                                    y2);
4725
4726                   tmp_node = tree->parent_node;
4727                   tmp_tree = tree->parent_tree;
4728
4729                   for (i = depth - 2; i > 0; i--)
4730                     {
4731                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
4732                         gdk_draw_line (event->window,
4733                                        tree_view->priv->tree_line_gc,
4734                                        x + tree_view->priv->expander_size * (i - 0.5) * mult,
4735                                        y0,
4736                                        x + tree_view->priv->expander_size * (i - 0.5) * mult,
4737                                        y2);
4738
4739                       tmp_node = tmp_tree->parent_node;
4740                       tmp_tree = tmp_tree->parent_tree;
4741                     }
4742                 }
4743             }
4744
4745           if (node == cursor && has_special_cell &&
4746               ((column == tree_view->priv->focus_column &&
4747                 GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) &&
4748                 GTK_WIDGET_HAS_FOCUS (widget)) ||
4749                (column == tree_view->priv->edited_column)))
4750             {
4751               _gtk_tree_view_column_cell_draw_focus (column,
4752                                                      event->window,
4753                                                      &background_area,
4754                                                      &cell_area,
4755                                                      &event->area,
4756                                                      flags);
4757             }
4758
4759           cell_offset += column->width;
4760         }
4761
4762       if (node == drag_highlight)
4763         {
4764           /* Draw indicator for the drop
4765            */
4766           gint highlight_y = -1;
4767           GtkRBTree *tree = NULL;
4768           GtkRBNode *node = NULL;
4769           gint width;
4770
4771           switch (tree_view->priv->drag_dest_pos)
4772             {
4773             case GTK_TREE_VIEW_DROP_BEFORE:
4774               highlight_y = background_area.y - 1;
4775               if (highlight_y < 0)
4776                       highlight_y = 0;
4777               break;
4778
4779             case GTK_TREE_VIEW_DROP_AFTER:
4780               highlight_y = background_area.y + background_area.height - 1;
4781               break;
4782
4783             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
4784             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
4785               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
4786
4787               if (tree == NULL)
4788                 break;
4789               gdk_drawable_get_size (tree_view->priv->bin_window,
4790                                      &width, NULL);
4791
4792               if (row_ending_details)
4793                 gtk_paint_focus (widget->style,
4794                                  tree_view->priv->bin_window,
4795                                  GTK_WIDGET_STATE (widget),
4796                                  &event->area,
4797                                  widget,
4798                                  (is_first
4799                                   ? (is_last ? "treeview-drop-indicator" : "treeview-drop-indicator-left" )
4800                                   : (is_last ? "treeview-drop-indicator-right" : "tree-view-drop-indicator-middle" )),
4801                                  0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node)
4802                                  - focus_line_width / 2,
4803                                  width, ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node))
4804                                - focus_line_width + 1);
4805               else
4806                 gtk_paint_focus (widget->style,
4807                                  tree_view->priv->bin_window,
4808                                  GTK_WIDGET_STATE (widget),
4809                                  &event->area,
4810                                  widget,
4811                                  "treeview-drop-indicator",
4812                                  0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node)
4813                                  - focus_line_width / 2,
4814                                  width, ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node))
4815                                  - focus_line_width + 1);
4816               break;
4817             }
4818
4819           if (highlight_y >= 0)
4820             {
4821               gdk_draw_line (event->window,
4822                              widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
4823                              rtl ? highlight_x + expander_cell_width : highlight_x,
4824                              highlight_y,
4825                              rtl ? 0 : bin_window_width,
4826                              highlight_y);
4827             }
4828         }
4829
4830       /* draw the big row-spanning focus rectangle, if needed */
4831       if (!has_special_cell && node == cursor &&
4832           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) &&
4833           GTK_WIDGET_HAS_FOCUS (widget))
4834         {
4835           gint tmp_y, tmp_height;
4836           gint width;
4837           GtkStateType focus_rect_state;
4838
4839           focus_rect_state =
4840             flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
4841             (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
4842              (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE :
4843               GTK_STATE_NORMAL));
4844
4845           gdk_drawable_get_size (tree_view->priv->bin_window,
4846                                  &width, NULL);
4847
4848           if (draw_hgrid_lines)
4849             {
4850               tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node) + grid_line_width / 2;
4851               tmp_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)) - grid_line_width;
4852             }
4853           else
4854             {
4855               tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
4856               tmp_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
4857             }
4858
4859           if (row_ending_details)
4860             gtk_paint_focus (widget->style,
4861                              tree_view->priv->bin_window,
4862                              focus_rect_state,
4863                              &event->area,
4864                              widget,
4865                              (is_first
4866                               ? (is_last ? "treeview" : "treeview-left" )
4867                               : (is_last ? "treeview-right" : "treeview-middle" )),
4868                              0, tmp_y,
4869                              width, tmp_height);
4870           else
4871             gtk_paint_focus (widget->style,
4872                              tree_view->priv->bin_window,
4873                              focus_rect_state,
4874                              &event->area,
4875                              widget,
4876                              "treeview",
4877                              0, tmp_y,
4878                              width, tmp_height);
4879         }
4880
4881       y_offset += max_height;
4882       if (node->children)
4883         {
4884           GtkTreeIter parent = iter;
4885           gboolean has_child;
4886
4887           tree = node->children;
4888           node = tree->root;
4889
4890           g_assert (node != tree->nil);
4891
4892           while (node->left != tree->nil)
4893             node = node->left;
4894           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
4895                                                     &iter,
4896                                                     &parent);
4897           depth++;
4898
4899           /* Sanity Check! */
4900           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
4901         }
4902       else
4903         {
4904           gboolean done = FALSE;
4905
4906           do
4907             {
4908               node = _gtk_rbtree_next (tree, node);
4909               if (node != NULL)
4910                 {
4911                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
4912                   done = TRUE;
4913
4914                   /* Sanity Check! */
4915                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
4916                 }
4917               else
4918                 {
4919                   GtkTreeIter parent_iter = iter;
4920                   gboolean has_parent;
4921
4922                   node = tree->parent_node;
4923                   tree = tree->parent_tree;
4924                   if (tree == NULL)
4925                     /* we should go to done to free some memory */
4926                     goto done;
4927                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
4928                                                            &iter,
4929                                                            &parent_iter);
4930                   depth--;
4931
4932                   /* Sanity check */
4933                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
4934                 }
4935             }
4936           while (!done);
4937         }
4938     }
4939   while (y_offset < event->area.height);
4940
4941 done:
4942   gtk_tree_view_draw_grid_lines (tree_view, event, n_visible_columns);
4943
4944  if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4945    {
4946      GdkRectangle *rectangles;
4947      gint n_rectangles;
4948
4949      gdk_region_get_rectangles (event->region,
4950                                 &rectangles,
4951                                 &n_rectangles);
4952
4953      while (n_rectangles--)
4954        gtk_tree_view_paint_rubber_band (tree_view, &rectangles[n_rectangles]);
4955
4956      g_free (rectangles);
4957    }
4958
4959   if (cursor_path)
4960     gtk_tree_path_free (cursor_path);
4961
4962   if (drag_dest_path)
4963     gtk_tree_path_free (drag_dest_path);
4964
4965   return FALSE;
4966 }
4967
4968 static gboolean
4969 gtk_tree_view_expose (GtkWidget      *widget,
4970                       GdkEventExpose *event)
4971 {
4972   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4973
4974   if (event->window == tree_view->priv->bin_window)
4975     {
4976       gboolean retval;
4977       GList *tmp_list;
4978
4979       retval = gtk_tree_view_bin_expose (widget, event);
4980
4981       /* We can't just chain up to Container::expose as it will try to send the
4982        * event to the headers, so we handle propagating it to our children
4983        * (eg. widgets being edited) ourselves.
4984        */
4985       tmp_list = tree_view->priv->children;
4986       while (tmp_list)
4987         {
4988           GtkTreeViewChild *child = tmp_list->data;
4989           tmp_list = tmp_list->next;
4990
4991           gtk_container_propagate_expose (GTK_CONTAINER (tree_view), child->widget, event);
4992         }
4993
4994       return retval;
4995     }
4996
4997   else if (event->window == tree_view->priv->header_window)
4998     {
4999       GList *list;
5000
5001       for (list = tree_view->priv->columns; list != NULL; list = list->next)
5002         {
5003           GtkTreeViewColumn *column = list->data;
5004
5005           if (column == tree_view->priv->drag_column)
5006             continue;
5007
5008           if (column->visible)
5009             gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
5010                                             column->button,
5011                                             event);
5012         }
5013     }
5014   else if (event->window == tree_view->priv->drag_window)
5015     {
5016       gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
5017                                       tree_view->priv->drag_column->button,
5018                                       event);
5019     }
5020   return TRUE;
5021 }
5022
5023 enum
5024 {
5025   DROP_HOME,
5026   DROP_RIGHT,
5027   DROP_LEFT,
5028   DROP_END
5029 };
5030
5031 /* returns 0x1 when no column has been found -- yes it's hackish */
5032 static GtkTreeViewColumn *
5033 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5034                                GtkTreeViewColumn *column,
5035                                gint               drop_position)
5036 {
5037   GtkTreeViewColumn *left_column = NULL;
5038   GtkTreeViewColumn *cur_column = NULL;
5039   GList *tmp_list;
5040
5041   if (!column->reorderable)
5042     return (GtkTreeViewColumn *)0x1;
5043
5044   switch (drop_position)
5045     {
5046       case DROP_HOME:
5047         /* find first column where we can drop */
5048         tmp_list = tree_view->priv->columns;
5049         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5050           return (GtkTreeViewColumn *)0x1;
5051
5052         while (tmp_list)
5053           {
5054             g_assert (tmp_list);
5055
5056             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5057             tmp_list = tmp_list->next;
5058
5059             if (left_column && left_column->visible == FALSE)
5060               continue;
5061
5062             if (!tree_view->priv->column_drop_func)
5063               return left_column;
5064
5065             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5066               {
5067                 left_column = cur_column;
5068                 continue;
5069               }
5070
5071             return left_column;
5072           }
5073
5074         if (!tree_view->priv->column_drop_func)
5075           return left_column;
5076
5077         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5078           return left_column;
5079         else
5080           return (GtkTreeViewColumn *)0x1;
5081         break;
5082
5083       case DROP_RIGHT:
5084         /* find first column after column where we can drop */
5085         tmp_list = tree_view->priv->columns;
5086
5087         for (; tmp_list; tmp_list = tmp_list->next)
5088           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5089             break;
5090
5091         if (!tmp_list || !tmp_list->next)
5092           return (GtkTreeViewColumn *)0x1;
5093
5094         tmp_list = tmp_list->next;
5095         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5096         tmp_list = tmp_list->next;
5097
5098         while (tmp_list)
5099           {
5100             g_assert (tmp_list);
5101
5102             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5103             tmp_list = tmp_list->next;
5104
5105             if (left_column && left_column->visible == FALSE)
5106               {
5107                 left_column = cur_column;
5108                 if (tmp_list)
5109                   tmp_list = tmp_list->next;
5110                 continue;
5111               }
5112
5113             if (!tree_view->priv->column_drop_func)
5114               return left_column;
5115
5116             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5117               {
5118                 left_column = cur_column;
5119                 continue;
5120               }
5121
5122             return left_column;
5123           }
5124
5125         if (!tree_view->priv->column_drop_func)
5126           return left_column;
5127
5128         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5129           return left_column;
5130         else
5131           return (GtkTreeViewColumn *)0x1;
5132         break;
5133
5134       case DROP_LEFT:
5135         /* find first column before column where we can drop */
5136         tmp_list = tree_view->priv->columns;
5137
5138         for (; tmp_list; tmp_list = tmp_list->next)
5139           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5140             break;
5141
5142         if (!tmp_list || !tmp_list->prev)
5143           return (GtkTreeViewColumn *)0x1;
5144
5145         tmp_list = tmp_list->prev;
5146         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5147         tmp_list = tmp_list->prev;
5148
5149         while (tmp_list)
5150           {
5151             g_assert (tmp_list);
5152
5153             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5154
5155             if (left_column && !left_column->visible)
5156               {
5157                 /*if (!tmp_list->prev)
5158                   return (GtkTreeViewColumn *)0x1;
5159                   */
5160 /*
5161                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5162                 tmp_list = tmp_list->prev->prev;
5163                 continue;*/
5164
5165                 cur_column = left_column;
5166                 if (tmp_list)
5167                   tmp_list = tmp_list->prev;
5168                 continue;
5169               }
5170
5171             if (!tree_view->priv->column_drop_func)
5172               return left_column;
5173
5174             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5175               return left_column;
5176
5177             cur_column = left_column;
5178             tmp_list = tmp_list->prev;
5179           }
5180
5181         if (!tree_view->priv->column_drop_func)
5182           return NULL;
5183
5184         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5185           return NULL;
5186         else
5187           return (GtkTreeViewColumn *)0x1;
5188         break;
5189
5190       case DROP_END:
5191         /* same as DROP_HOME case, but doing it backwards */
5192         tmp_list = g_list_last (tree_view->priv->columns);
5193         cur_column = NULL;
5194
5195         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5196           return (GtkTreeViewColumn *)0x1;
5197
5198         while (tmp_list)
5199           {
5200             g_assert (tmp_list);
5201
5202             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5203
5204             if (left_column && !left_column->visible)
5205               {
5206                 cur_column = left_column;
5207                 tmp_list = tmp_list->prev;
5208               }
5209
5210             if (!tree_view->priv->column_drop_func)
5211               return left_column;
5212
5213             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5214               return left_column;
5215
5216             cur_column = left_column;
5217             tmp_list = tmp_list->prev;
5218           }
5219
5220         if (!tree_view->priv->column_drop_func)
5221           return NULL;
5222
5223         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5224           return NULL;
5225         else
5226           return (GtkTreeViewColumn *)0x1;
5227         break;
5228     }
5229
5230   return (GtkTreeViewColumn *)0x1;
5231 }
5232
5233 static gboolean
5234 gtk_tree_view_key_press (GtkWidget   *widget,
5235                          GdkEventKey *event)
5236 {
5237   GtkTreeView *tree_view = (GtkTreeView *) widget;
5238
5239   if (tree_view->priv->rubber_band_status)
5240     {
5241       if (event->keyval == GDK_Escape)
5242         gtk_tree_view_stop_rubber_band (tree_view);
5243
5244       return TRUE;
5245     }
5246
5247   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
5248     {
5249       if (event->keyval == GDK_Escape)
5250         {
5251           tree_view->priv->cur_reorder = NULL;
5252           gtk_tree_view_button_release_drag_column (widget, NULL);
5253         }
5254       return TRUE;
5255     }
5256
5257   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
5258     {
5259       GList *focus_column;
5260       gboolean rtl;
5261
5262       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5263
5264       for (focus_column = tree_view->priv->columns;
5265            focus_column;
5266            focus_column = focus_column->next)
5267         {
5268           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5269
5270           if (GTK_WIDGET_HAS_FOCUS (column->button))
5271             break;
5272         }
5273
5274       if (focus_column &&
5275           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5276           (event->keyval == GDK_Left || event->keyval == GDK_KP_Left
5277            || event->keyval == GDK_Right || event->keyval == GDK_KP_Right))
5278         {
5279           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5280
5281           if (!column->resizable)
5282             {
5283               gtk_widget_error_bell (widget);
5284               return TRUE;
5285             }
5286
5287           if (event->keyval == (rtl ? GDK_Right : GDK_Left)
5288               || event->keyval == (rtl ? GDK_KP_Right : GDK_KP_Left))
5289             {
5290               gint old_width = column->resized_width;
5291
5292               column->resized_width = MAX (column->resized_width,
5293                                            column->width);
5294               column->resized_width -= 2;
5295               if (column->resized_width < 0)
5296                 column->resized_width = 0;
5297
5298               if (column->min_width == -1)
5299                 column->resized_width = MAX (column->button->requisition.width,
5300                                              column->resized_width);
5301               else
5302                 column->resized_width = MAX (column->min_width,
5303                                              column->resized_width);
5304
5305               if (column->max_width != -1)
5306                 column->resized_width = MIN (column->resized_width,
5307                                              column->max_width);
5308
5309               column->use_resized_width = TRUE;
5310
5311               if (column->resized_width != old_width)
5312                 gtk_widget_queue_resize (widget);
5313               else
5314                 gtk_widget_error_bell (widget);
5315             }
5316           else if (event->keyval == (rtl ? GDK_Left : GDK_Right)
5317                    || event->keyval == (rtl ? GDK_KP_Left : GDK_KP_Right))
5318             {
5319               gint old_width = column->resized_width;
5320
5321               column->resized_width = MAX (column->resized_width,
5322                                            column->width);
5323               column->resized_width += 2;
5324
5325               if (column->max_width != -1)
5326                 column->resized_width = MIN (column->resized_width,
5327                                              column->max_width);
5328
5329               column->use_resized_width = TRUE;
5330
5331               if (column->resized_width != old_width)
5332                 gtk_widget_queue_resize (widget);
5333               else
5334                 gtk_widget_error_bell (widget);
5335             }
5336
5337           return TRUE;
5338         }
5339
5340       if (focus_column &&
5341           (event->state & GDK_MOD1_MASK) &&
5342           (event->keyval == GDK_Left || event->keyval == GDK_KP_Left
5343            || event->keyval == GDK_Right || event->keyval == GDK_KP_Right
5344            || event->keyval == GDK_Home || event->keyval == GDK_KP_Home
5345            || event->keyval == GDK_End || event->keyval == GDK_KP_End))
5346         {
5347           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5348
5349           if (event->keyval == (rtl ? GDK_Right : GDK_Left)
5350               || event->keyval == (rtl ? GDK_KP_Right : GDK_KP_Left))
5351             {
5352               GtkTreeViewColumn *col;
5353               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5354               if (col != (GtkTreeViewColumn *)0x1)
5355                 gtk_tree_view_move_column_after (tree_view, column, col);
5356               else
5357                 gtk_widget_error_bell (widget);
5358             }
5359           else if (event->keyval == (rtl ? GDK_Left : GDK_Right)
5360                    || event->keyval == (rtl ? GDK_KP_Left : GDK_KP_Right))
5361             {
5362               GtkTreeViewColumn *col;
5363               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5364               if (col != (GtkTreeViewColumn *)0x1)
5365                 gtk_tree_view_move_column_after (tree_view, column, col);
5366               else
5367                 gtk_widget_error_bell (widget);
5368             }
5369           else if (event->keyval == GDK_Home || event->keyval == GDK_KP_Home)
5370             {
5371               GtkTreeViewColumn *col;
5372               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5373               if (col != (GtkTreeViewColumn *)0x1)
5374                 gtk_tree_view_move_column_after (tree_view, column, col);
5375               else
5376                 gtk_widget_error_bell (widget);
5377             }
5378           else if (event->keyval == GDK_End || event->keyval == GDK_KP_End)
5379             {
5380               GtkTreeViewColumn *col;
5381               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
5382               if (col != (GtkTreeViewColumn *)0x1)
5383                 gtk_tree_view_move_column_after (tree_view, column, col);
5384               else
5385                 gtk_widget_error_bell (widget);
5386             }
5387
5388           return TRUE;
5389         }
5390     }
5391
5392   /* Chain up to the parent class.  It handles the keybindings. */
5393   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5394     return TRUE;
5395
5396   if (tree_view->priv->search_entry_avoid_unhandled_binding)
5397     {
5398       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
5399       return FALSE;
5400     }
5401
5402   /* We pass the event to the search_entry.  If its text changes, then we start
5403    * the typeahead find capabilities. */
5404   if (GTK_WIDGET_HAS_FOCUS (tree_view)
5405       && tree_view->priv->enable_search
5406       && !tree_view->priv->search_custom_entry_set)
5407     {
5408       GdkEvent *new_event;
5409       char *old_text;
5410       const char *new_text;
5411       gboolean retval;
5412       GdkScreen *screen;
5413       gboolean text_modified;
5414       gulong popup_menu_id;
5415
5416       gtk_tree_view_ensure_interactive_directory (tree_view);
5417
5418       /* Make a copy of the current text */
5419       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5420       new_event = gdk_event_copy ((GdkEvent *) event);
5421       g_object_unref (((GdkEventKey *) new_event)->window);
5422       ((GdkEventKey *) new_event)->window = g_object_ref (tree_view->priv->search_window->window);
5423       gtk_widget_realize (tree_view->priv->search_window);
5424
5425       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5426                                         "popup-menu", G_CALLBACK (gtk_true),
5427                                         NULL);
5428
5429       /* Move the entry off screen */
5430       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5431       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5432                        gdk_screen_get_width (screen) + 1,
5433                        gdk_screen_get_height (screen) + 1);
5434       gtk_widget_show (tree_view->priv->search_window);
5435
5436       /* Send the event to the window.  If the preedit_changed signal is emitted
5437        * during this event, we will set priv->imcontext_changed  */
5438       tree_view->priv->imcontext_changed = FALSE;
5439       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5440       gdk_event_free (new_event);
5441       gtk_widget_hide (tree_view->priv->search_window);
5442
5443       g_signal_handler_disconnect (tree_view->priv->search_entry,
5444                                    popup_menu_id);
5445
5446       /* We check to make sure that the entry tried to handle the text, and that
5447        * the text has changed.
5448        */
5449       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5450       text_modified = strcmp (old_text, new_text) != 0;
5451       g_free (old_text);
5452       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5453           (retval && text_modified))               /* ...or the text was modified */
5454         {
5455           if (gtk_tree_view_real_start_interactive_search (tree_view, FALSE))
5456             {
5457               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5458               return TRUE;
5459             }
5460           else
5461             {
5462               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5463               return FALSE;
5464             }
5465         }
5466     }
5467
5468   return FALSE;
5469 }
5470
5471 static gboolean
5472 gtk_tree_view_key_release (GtkWidget   *widget,
5473                            GdkEventKey *event)
5474 {
5475   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5476
5477   if (tree_view->priv->rubber_band_status)
5478     return TRUE;
5479
5480   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5481 }
5482
5483 /* FIXME Is this function necessary? Can I get an enter_notify event
5484  * w/o either an expose event or a mouse motion event?
5485  */
5486 static gboolean
5487 gtk_tree_view_enter_notify (GtkWidget        *widget,
5488                             GdkEventCrossing *event)
5489 {
5490   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5491   GtkRBTree *tree;
5492   GtkRBNode *node;
5493   gint new_y;
5494
5495   /* Sanity check it */
5496   if (event->window != tree_view->priv->bin_window)
5497     return FALSE;
5498
5499   if (tree_view->priv->tree == NULL)
5500     return FALSE;
5501
5502   if (event->mode == GDK_CROSSING_GRAB ||
5503       event->mode == GDK_CROSSING_GTK_GRAB ||
5504       event->mode == GDK_CROSSING_GTK_UNGRAB ||
5505       event->mode == GDK_CROSSING_STATE_CHANGED)
5506     return TRUE;
5507
5508   /* find the node internally */
5509   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5510   if (new_y < 0)
5511     new_y = 0;
5512   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5513
5514   if ((tree_view->priv->button_pressed_node == NULL) ||
5515       (tree_view->priv->button_pressed_node == node))
5516     prelight_or_select (tree_view, tree, node, event->x, event->y);
5517
5518   return TRUE;
5519 }
5520
5521 static gboolean
5522 gtk_tree_view_leave_notify (GtkWidget        *widget,
5523                             GdkEventCrossing *event)
5524 {
5525   GtkTreeView *tree_view;
5526
5527   if (event->mode == GDK_CROSSING_GRAB)
5528     return TRUE;
5529
5530   tree_view = GTK_TREE_VIEW (widget);
5531
5532   if (tree_view->priv->prelight_node)
5533     _gtk_tree_view_queue_draw_node (tree_view,
5534                                    tree_view->priv->prelight_tree,
5535                                    tree_view->priv->prelight_node,
5536                                    NULL);
5537
5538   prelight_or_select (tree_view,
5539                       NULL, NULL,
5540                       -1000, -1000); /* coords not possibly over an arrow */
5541
5542   return TRUE;
5543 }
5544
5545
5546 static gint
5547 gtk_tree_view_focus_out (GtkWidget     *widget,
5548                          GdkEventFocus *event)
5549 {
5550   GtkTreeView *tree_view;
5551
5552   tree_view = GTK_TREE_VIEW (widget);
5553
5554   gtk_widget_queue_draw (widget);
5555
5556   /* destroy interactive search dialog */
5557   if (tree_view->priv->search_window)
5558     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view);
5559
5560   return FALSE;
5561 }
5562
5563
5564 /* Incremental Reflow
5565  */
5566
5567 static void
5568 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
5569                                  GtkRBTree   *tree,
5570                                  GtkRBNode   *node)
5571 {
5572   gint y;
5573
5574   y = _gtk_rbtree_node_find_offset (tree, node)
5575     - tree_view->priv->vadjustment->value
5576     + TREE_VIEW_HEADER_HEIGHT (tree_view);
5577
5578   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
5579                               0, y,
5580                               GTK_WIDGET (tree_view)->allocation.width,
5581                               GTK_RBNODE_GET_HEIGHT (node));
5582 }
5583
5584 static gboolean
5585 node_is_visible (GtkTreeView *tree_view,
5586                  GtkRBTree   *tree,
5587                  GtkRBNode   *node)
5588 {
5589   int y;
5590   int height;
5591
5592   y = _gtk_rbtree_node_find_offset (tree, node);
5593   height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5594
5595   if (y >= tree_view->priv->vadjustment->value &&
5596       y + height <= (tree_view->priv->vadjustment->value
5597                      + tree_view->priv->vadjustment->page_size))
5598     return TRUE;
5599
5600   return FALSE;
5601 }
5602
5603 /* Returns TRUE if it updated the size
5604  */
5605 static gboolean
5606 validate_row (GtkTreeView *tree_view,
5607               GtkRBTree   *tree,
5608               GtkRBNode   *node,
5609               GtkTreeIter *iter,
5610               GtkTreePath *path)
5611 {
5612   GtkTreeViewColumn *column;
5613   GList *list, *first_column, *last_column;
5614   gint height = 0;
5615   gint horizontal_separator;
5616   gint vertical_separator;
5617   gint focus_line_width;
5618   gint depth = gtk_tree_path_get_depth (path);
5619   gboolean retval = FALSE;
5620   gboolean is_separator = FALSE;
5621   gboolean draw_vgrid_lines, draw_hgrid_lines;
5622   gint focus_pad;
5623   gint grid_line_width;
5624   gboolean wide_separators;
5625   gint separator_height;
5626
5627   /* double check the row needs validating */
5628   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
5629       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5630     return FALSE;
5631
5632   is_separator = row_is_separator (tree_view, iter, NULL);
5633
5634   gtk_widget_style_get (GTK_WIDGET (tree_view),
5635                         "focus-padding", &focus_pad,
5636                         "focus-line-width", &focus_line_width,
5637                         "horizontal-separator", &horizontal_separator,
5638                         "vertical-separator", &vertical_separator,
5639                         "grid-line-width", &grid_line_width,
5640                         "wide-separators",  &wide_separators,
5641                         "separator-height", &separator_height,
5642                         NULL);
5643
5644   draw_vgrid_lines =
5645     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
5646     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
5647   draw_hgrid_lines =
5648     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
5649     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
5650
5651   for (last_column = g_list_last (tree_view->priv->columns);
5652        last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible);
5653        last_column = last_column->prev)
5654     ;
5655
5656   for (first_column = g_list_first (tree_view->priv->columns);
5657        first_column && !(GTK_TREE_VIEW_COLUMN (first_column->data)->visible);
5658        first_column = first_column->next)
5659     ;
5660
5661   for (list = tree_view->priv->columns; list; list = list->next)
5662     {
5663       GtkTreeViewColumnPrivate *column_priv;
5664       GtkRequisition requested_size;
5665       GtkRequisition natural_size;
5666       gint padding;
5667
5668       column = list->data;
5669       column_priv = GTK_TREE_VIEW_COLUMN_GET_PRIVATE (column);
5670
5671       if (! column->visible)
5672         continue;
5673
5674       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) && !column->dirty)
5675         continue;
5676
5677       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
5678                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
5679                                                node->children?TRUE:FALSE);
5680       gtk_tree_view_column_cell_get_size (column,
5681                                           NULL, NULL, NULL,
5682                                           &requested_size.width,
5683                                           &requested_size.height);
5684       gtk_extended_layout_get_desired_size (GTK_EXTENDED_LAYOUT (column),
5685                                             NULL, &natural_size);
5686
5687       if (!is_separator)
5688         {
5689           requested_size.height += vertical_separator;
5690           height = MAX (height, requested_size.height);
5691           height = MAX (height, tree_view->priv->expander_size);
5692         }
5693       else
5694         {
5695           if (wide_separators)
5696             height = separator_height + 2 * focus_pad;
5697           else
5698             height = 2 + 2 * focus_pad;
5699         }
5700
5701       if (gtk_tree_view_is_expander_column (tree_view, column))
5702         {
5703           padding = horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
5704
5705           if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
5706             padding += depth * tree_view->priv->expander_size;
5707         }
5708       else
5709         padding = horizontal_separator;
5710
5711       if (draw_vgrid_lines)
5712         {
5713           if (list->data == first_column || list->data == last_column)
5714             padding += grid_line_width / 2.0;
5715           else
5716             padding += grid_line_width;
5717         }
5718
5719       requested_size.width += padding;
5720       natural_size.width += padding;
5721
5722       if (requested_size.width > column->requested_width ||
5723           natural_size.width > column_priv->natural_width)
5724         {
5725           retval = TRUE;
5726           column->requested_width = requested_size.width;
5727           column_priv->natural_width = natural_size.width;
5728         }
5729     }
5730
5731   if (draw_hgrid_lines)
5732     height += grid_line_width;
5733
5734   if (height != GTK_RBNODE_GET_HEIGHT (node))
5735     {
5736       retval = TRUE;
5737       _gtk_rbtree_node_set_height (tree, node, height);
5738     }
5739   _gtk_rbtree_node_mark_valid (tree, node);
5740   tree_view->priv->post_validation_flag = TRUE;
5741
5742   return retval;
5743 }
5744
5745
5746 static void
5747 validate_visible_area (GtkTreeView *tree_view)
5748 {
5749   GtkTreePath *path = NULL;
5750   GtkTreePath *above_path = NULL;
5751   GtkTreeIter iter;
5752   GtkRBTree *tree = NULL;
5753   GtkRBNode *node = NULL;
5754   gboolean need_redraw = FALSE;
5755   gboolean size_changed = FALSE;
5756   gint total_height;
5757   gint area_above = 0;
5758   gint area_below = 0;
5759
5760   if (tree_view->priv->tree == NULL)
5761     return;
5762
5763   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
5764       tree_view->priv->scroll_to_path == NULL)
5765     return;
5766
5767   total_height = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
5768
5769   if (total_height == 0)
5770     return;
5771
5772   /* First, we check to see if we need to scroll anywhere
5773    */
5774   if (tree_view->priv->scroll_to_path)
5775     {
5776       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
5777       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
5778         {
5779           /* we are going to scroll, and will update dy */
5780           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
5781           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
5782               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5783             {
5784               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
5785               if (validate_row (tree_view, tree, node, &iter, path))
5786                 size_changed = TRUE;
5787             }
5788
5789           if (tree_view->priv->scroll_to_use_align)
5790             {
5791               gint height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5792               area_above = (total_height - height) *
5793                 tree_view->priv->scroll_to_row_align;
5794               area_below = total_height - area_above - height;
5795               area_above = MAX (area_above, 0);
5796               area_below = MAX (area_below, 0);
5797             }
5798           else
5799             {
5800               /* two cases:
5801                * 1) row not visible
5802                * 2) row visible
5803                */
5804               gint dy;
5805               gint height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5806
5807               dy = _gtk_rbtree_node_find_offset (tree, node);
5808
5809               if (dy >= tree_view->priv->vadjustment->value &&
5810                   dy + height <= (tree_view->priv->vadjustment->value
5811                                   + tree_view->priv->vadjustment->page_size))
5812                 {
5813                   /* row visible: keep the row at the same position */
5814                   area_above = dy - tree_view->priv->vadjustment->value;
5815                   area_below = (tree_view->priv->vadjustment->value +
5816                                 tree_view->priv->vadjustment->page_size)
5817                                - dy - height;
5818                 }
5819               else
5820                 {
5821                   /* row not visible */
5822                   if (dy >= 0
5823                       && dy + height <= tree_view->priv->vadjustment->page_size)
5824                     {
5825                       /* row at the beginning -- fixed */
5826                       area_above = dy;
5827                       area_below = tree_view->priv->vadjustment->page_size
5828                                    - area_above - height;
5829                     }
5830                   else if (dy >= (tree_view->priv->vadjustment->upper -
5831                                   tree_view->priv->vadjustment->page_size))
5832                     {
5833                       /* row at the end -- fixed */
5834                       area_above = dy - (tree_view->priv->vadjustment->upper -
5835                                    tree_view->priv->vadjustment->page_size);
5836                       area_below = tree_view->priv->vadjustment->page_size -
5837                                    area_above - height;
5838
5839                       if (area_below < 0)
5840                         {
5841                           area_above = tree_view->priv->vadjustment->page_size - height;
5842                           area_below = 0;
5843                         }
5844                     }
5845                   else
5846                     {
5847                       /* row somewhere in the middle, bring it to the top
5848                        * of the view
5849                        */
5850                       area_above = 0;
5851                       area_below = total_height - height;
5852                     }
5853                 }
5854             }
5855         }
5856       else
5857         /* the scroll to isn't valid; ignore it.
5858          */
5859         {
5860           if (tree_view->priv->scroll_to_path && !path)
5861             {
5862               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
5863               tree_view->priv->scroll_to_path = NULL;
5864             }
5865           if (path)
5866             gtk_tree_path_free (path);
5867           path = NULL;
5868         }
5869     }
5870
5871   /* We didn't have a scroll_to set, so we just handle things normally
5872    */
5873   if (path == NULL)
5874     {
5875       gint offset;
5876
5877       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
5878                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
5879                                         &tree, &node);
5880       if (node == NULL)
5881         {
5882           /* In this case, nothing has been validated */
5883           path = gtk_tree_path_new_first ();
5884           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
5885         }
5886       else
5887         {
5888           path = _gtk_tree_view_find_path (tree_view, tree, node);
5889           total_height += offset;
5890         }
5891
5892       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
5893
5894       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
5895           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5896         {
5897           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
5898           if (validate_row (tree_view, tree, node, &iter, path))
5899             size_changed = TRUE;
5900         }
5901       area_above = 0;
5902       area_below = total_height - ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5903     }
5904
5905   above_path = gtk_tree_path_copy (path);
5906
5907   /* if we do not validate any row above the new top_row, we will make sure
5908    * that the row immediately above top_row has been validated. (if we do not
5909    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
5910    * when invalidated that row's height will be zero. and this will mess up
5911    * scrolling).
5912    */
5913   if (area_above == 0)
5914     {
5915       GtkRBTree *tmptree;
5916       GtkRBNode *tmpnode;
5917
5918       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
5919       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
5920
5921       if (tmpnode)
5922         {
5923           GtkTreePath *tmppath;
5924           GtkTreeIter tmpiter;
5925
5926           tmppath = _gtk_tree_view_find_path (tree_view, tmptree, tmpnode);
5927           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
5928
5929           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
5930               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
5931             {
5932               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
5933               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
5934                 size_changed = TRUE;
5935             }
5936
5937           gtk_tree_path_free (tmppath);
5938         }
5939     }
5940
5941   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
5942    * backwards is much slower then forward, as there is no iter_prev function.
5943    * We go forwards first in case we run out of tree.  Then we go backwards to
5944    * fill out the top.
5945    */
5946   while (node && area_below > 0)
5947     {
5948       if (node->children)
5949         {
5950           GtkTreeIter parent = iter;
5951           gboolean has_child;
5952
5953           tree = node->children;
5954           node = tree->root;
5955
5956           g_assert (node != tree->nil);
5957
5958           while (node->left != tree->nil)
5959             node = node->left;
5960           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
5961                                                     &iter,
5962                                                     &parent);
5963           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
5964           gtk_tree_path_down (path);
5965         }
5966       else
5967         {
5968           gboolean done = FALSE;
5969           do
5970             {
5971               node = _gtk_rbtree_next (tree, node);
5972               if (node != NULL)
5973                 {
5974                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
5975                   done = TRUE;
5976                   gtk_tree_path_next (path);
5977
5978                   /* Sanity Check! */
5979                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
5980                 }
5981               else
5982                 {
5983                   GtkTreeIter parent_iter = iter;
5984                   gboolean has_parent;
5985
5986                   node = tree->parent_node;
5987                   tree = tree->parent_tree;
5988                   if (tree == NULL)
5989                     break;
5990                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
5991                                                            &iter,
5992                                                            &parent_iter);
5993                   gtk_tree_path_up (path);
5994
5995                   /* Sanity check */
5996                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
5997                 }
5998             }
5999           while (!done);
6000         }
6001
6002       if (!node)
6003         break;
6004
6005       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6006           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6007         {
6008           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6009           if (validate_row (tree_view, tree, node, &iter, path))
6010               size_changed = TRUE;
6011         }
6012
6013       area_below -= ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
6014     }
6015   gtk_tree_path_free (path);
6016
6017   /* If we ran out of tree, and have extra area_below left, we need to add it
6018    * to area_above */
6019   if (area_below > 0)
6020     area_above += area_below;
6021
6022   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
6023
6024   /* We walk backwards */
6025   while (area_above > 0)
6026     {
6027       _gtk_rbtree_prev_full (tree, node, &tree, &node);
6028
6029       /* Always find the new path in the tree.  We cannot just assume
6030        * a gtk_tree_path_prev() is enough here, as there might be children
6031        * in between this node and the previous sibling node.  If this
6032        * appears to be a performance hotspot in profiles, we can look into
6033        * intrigate logic for keeping path, node and iter in sync like
6034        * we do for forward walks.  (Which will be hard because of the lacking
6035        * iter_prev).
6036        */
6037
6038       if (node == NULL)
6039         break;
6040
6041       gtk_tree_path_free (above_path);
6042       above_path = _gtk_tree_view_find_path (tree_view, tree, node);
6043
6044       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
6045
6046       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6047           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6048         {
6049           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6050           if (validate_row (tree_view, tree, node, &iter, above_path))
6051             size_changed = TRUE;
6052         }
6053       area_above -= ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
6054     }
6055
6056   /* if we scrolled to a path, we need to set the dy here,
6057    * and sync the top row accordingly
6058    */
6059   if (tree_view->priv->scroll_to_path)
6060     {
6061       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6062       gtk_tree_view_top_row_to_dy (tree_view);
6063
6064       need_redraw = TRUE;
6065     }
6066   else if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
6067     {
6068       /* when we are not scrolling, we should never set dy to something
6069        * else than zero. we update top_row to be in sync with dy = 0.
6070        */
6071       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6072       gtk_tree_view_dy_to_top_row (tree_view);
6073     }
6074   else if (tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
6075     {
6076       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - tree_view->priv->vadjustment->page_size);
6077       gtk_tree_view_dy_to_top_row (tree_view);
6078     }
6079   else
6080     gtk_tree_view_top_row_to_dy (tree_view);
6081
6082   /* update width/height and queue a resize */
6083   if (size_changed)
6084     {
6085       GtkRequisition requisition;
6086
6087       /* We temporarily guess a size, under the assumption that it will be the
6088        * same when we get our next size_allocate.  If we don't do this, we'll be
6089        * in an inconsistent state if we call top_row_to_dy. */
6090
6091       gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
6092       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6093       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6094       gtk_adjustment_changed (tree_view->priv->hadjustment);
6095       gtk_adjustment_changed (tree_view->priv->vadjustment);
6096       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6097     }
6098
6099   if (tree_view->priv->scroll_to_path)
6100     {
6101       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6102       tree_view->priv->scroll_to_path = NULL;
6103     }
6104
6105   if (above_path)
6106     gtk_tree_path_free (above_path);
6107
6108   if (tree_view->priv->scroll_to_column)
6109     {
6110       tree_view->priv->scroll_to_column = NULL;
6111     }
6112   if (need_redraw)
6113     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6114 }
6115
6116 static void
6117 initialize_fixed_height_mode (GtkTreeView *tree_view)
6118 {
6119   if (!tree_view->priv->tree)
6120     return;
6121
6122   if (tree_view->priv->fixed_height < 0)
6123     {
6124       GtkTreeIter iter;
6125       GtkTreePath *path;
6126
6127       GtkRBTree *tree = NULL;
6128       GtkRBNode *node = NULL;
6129
6130       tree = tree_view->priv->tree;
6131       node = tree->root;
6132
6133       path = _gtk_tree_view_find_path (tree_view, tree, node);
6134       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6135
6136       validate_row (tree_view, tree, node, &iter, path);
6137
6138       gtk_tree_path_free (path);
6139
6140       tree_view->priv->fixed_height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
6141     }
6142
6143    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6144                                  tree_view->priv->fixed_height, TRUE);
6145 }
6146
6147 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6148  * the left-most uninvalidated node.  We then try walking right, validating
6149  * nodes.  Once we find a valid node, we repeat the previous process of finding
6150  * the first invalid node.
6151  */
6152
6153 static gboolean
6154 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6155 {
6156   GtkRBTree *tree = NULL;
6157   GtkRBNode *node = NULL;
6158   gboolean validated_area = FALSE;
6159   gint retval = TRUE;
6160   GtkTreePath *path = NULL;
6161   GtkTreeIter iter;
6162   GTimer *timer;
6163   gint i = 0;
6164
6165   gint prev_height = -1;
6166   gboolean fixed_height = TRUE;
6167
6168   g_assert (tree_view);
6169
6170   if (tree_view->priv->tree == NULL)
6171       return FALSE;
6172
6173   if (tree_view->priv->fixed_height_mode)
6174     {
6175       if (tree_view->priv->fixed_height < 0)
6176         initialize_fixed_height_mode (tree_view);
6177
6178       return FALSE;
6179     }
6180
6181   timer = g_timer_new ();
6182   g_timer_start (timer);
6183
6184   do
6185     {
6186       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6187         {
6188           retval = FALSE;
6189           goto done;
6190         }
6191
6192       if (path != NULL)
6193         {
6194           node = _gtk_rbtree_next (tree, node);
6195           if (node != NULL)
6196             {
6197               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6198               gtk_tree_path_next (path);
6199             }
6200           else
6201             {
6202               gtk_tree_path_free (path);
6203               path = NULL;
6204             }
6205         }
6206
6207       if (path == NULL)
6208         {
6209           tree = tree_view->priv->tree;
6210           node = tree_view->priv->tree->root;
6211
6212           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6213
6214           do
6215             {
6216               if (node->left != tree->nil &&
6217                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6218                 {
6219                   node = node->left;
6220                 }
6221               else if (node->right != tree->nil &&
6222                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6223                 {
6224                   node = node->right;
6225                 }
6226               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6227                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6228                 {
6229                   break;
6230                 }
6231               else if (node->children != NULL)
6232                 {
6233                   tree = node->children;
6234                   node = tree->root;
6235                 }
6236               else
6237                 /* RBTree corruption!  All bad */
6238                 g_assert_not_reached ();
6239             }
6240           while (TRUE);
6241           path = _gtk_tree_view_find_path (tree_view, tree, node);
6242           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6243         }
6244
6245       validated_area = validate_row (tree_view, tree, node, &iter, path) ||
6246                        validated_area;
6247
6248       if (!tree_view->priv->fixed_height_check)
6249         {
6250           gint height;
6251
6252           height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
6253           if (prev_height < 0)
6254             prev_height = height;
6255           else if (prev_height != height)
6256             fixed_height = FALSE;
6257         }
6258
6259       i++;
6260     }
6261   while (g_timer_elapsed (timer, NULL) < GTK_TREE_VIEW_TIME_MS_PER_IDLE / 1000.);
6262
6263   if (!tree_view->priv->fixed_height_check)
6264    {
6265      if (fixed_height)
6266        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6267
6268      tree_view->priv->fixed_height_check = 1;
6269    }
6270
6271  done:
6272   if (validated_area)
6273     {
6274       GtkRequisition requisition;
6275       /* We temporarily guess a size, under the assumption that it will be the
6276        * same when we get our next size_allocate.  If we don't do this, we'll be
6277        * in an inconsistent state when we call top_row_to_dy. */
6278
6279       gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
6280       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6281       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6282       gtk_adjustment_changed (tree_view->priv->hadjustment);
6283       gtk_adjustment_changed (tree_view->priv->vadjustment);
6284
6285       if (queue_resize)
6286         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6287     }
6288
6289   if (path) gtk_tree_path_free (path);
6290   g_timer_destroy (timer);
6291
6292   return retval;
6293 }
6294
6295 static gboolean
6296 validate_rows (GtkTreeView *tree_view)
6297 {
6298   gboolean retval;
6299
6300   retval = do_validate_rows (tree_view, TRUE);
6301
6302   if (! retval && tree_view->priv->validate_rows_timer)
6303     {
6304       g_source_remove (tree_view->priv->validate_rows_timer);
6305       tree_view->priv->validate_rows_timer = 0;
6306     }
6307
6308   return retval;
6309 }
6310
6311 static gboolean
6312 validate_rows_handler (GtkTreeView *tree_view)
6313 {
6314   gboolean retval;
6315
6316   retval = do_validate_rows (tree_view, TRUE);
6317   if (! retval && tree_view->priv->validate_rows_timer)
6318     {
6319       g_source_remove (tree_view->priv->validate_rows_timer);
6320       tree_view->priv->validate_rows_timer = 0;
6321     }
6322
6323   return retval;
6324 }
6325
6326 static gboolean
6327 do_presize_handler (GtkTreeView *tree_view)
6328 {
6329   if (tree_view->priv->mark_rows_col_dirty)
6330     {
6331       if (tree_view->priv->tree)
6332         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6333       tree_view->priv->mark_rows_col_dirty = FALSE;
6334     }
6335   validate_visible_area (tree_view);
6336   tree_view->priv->presize_handler_timer = 0;
6337
6338   if (tree_view->priv->fixed_height_mode)
6339     {
6340       GtkRequisition requisition;
6341
6342       gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
6343
6344       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6345       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6346       gtk_adjustment_changed (tree_view->priv->hadjustment);
6347       gtk_adjustment_changed (tree_view->priv->vadjustment);
6348       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6349     }
6350
6351   return FALSE;
6352 }
6353
6354 static gboolean
6355 presize_handler_callback (gpointer data)
6356 {
6357   do_presize_handler (GTK_TREE_VIEW (data));
6358
6359   return FALSE;
6360 }
6361
6362 static void
6363 install_presize_handler (GtkTreeView *tree_view)
6364 {
6365   if (! GTK_WIDGET_REALIZED (tree_view))
6366     return;
6367
6368   if (! tree_view->priv->presize_handler_timer)
6369     {
6370       tree_view->priv->presize_handler_timer =
6371         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6372     }
6373   if (! tree_view->priv->validate_rows_timer)
6374     {
6375       tree_view->priv->validate_rows_timer =
6376         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6377     }
6378 }
6379
6380 static gboolean
6381 scroll_sync_handler (GtkTreeView *tree_view)
6382 {
6383   if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
6384     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6385   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6386     gtk_tree_view_top_row_to_dy (tree_view);
6387   else
6388     gtk_tree_view_dy_to_top_row (tree_view);
6389
6390   tree_view->priv->scroll_sync_timer = 0;
6391
6392   return FALSE;
6393 }
6394
6395 static void
6396 install_scroll_sync_handler (GtkTreeView *tree_view)
6397 {
6398   if (! GTK_WIDGET_REALIZED (tree_view))
6399     return;
6400
6401   if (!tree_view->priv->scroll_sync_timer)
6402     {
6403       tree_view->priv->scroll_sync_timer =
6404         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6405     }
6406 }
6407
6408 static void
6409 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6410                            GtkTreePath *path,
6411                            gint         offset)
6412 {
6413   gtk_tree_row_reference_free (tree_view->priv->top_row);
6414
6415   if (!path)
6416     {
6417       tree_view->priv->top_row = NULL;
6418       tree_view->priv->top_row_dy = 0;
6419     }
6420   else
6421     {
6422       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6423       tree_view->priv->top_row_dy = offset;
6424     }
6425 }
6426
6427 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6428  * it's set to be NULL, and top_row_dy is 0;
6429  */
6430 static void
6431 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6432 {
6433   gint offset;
6434   GtkTreePath *path;
6435   GtkRBTree *tree;
6436   GtkRBNode *node;
6437
6438   if (tree_view->priv->tree == NULL)
6439     {
6440       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6441     }
6442   else
6443     {
6444       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6445                                         tree_view->priv->dy,
6446                                         &tree, &node);
6447
6448       if (tree == NULL)
6449         {
6450           tree_view->priv->top_row = NULL;
6451           tree_view->priv->top_row_dy = 0;
6452         }
6453       else
6454         {
6455           path = _gtk_tree_view_find_path (tree_view, tree, node);
6456           gtk_tree_view_set_top_row (tree_view, path, offset);
6457           gtk_tree_path_free (path);
6458         }
6459     }
6460 }
6461
6462 static void
6463 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6464 {
6465   GtkTreePath *path;
6466   GtkRBTree *tree;
6467   GtkRBNode *node;
6468   int new_dy;
6469
6470   /* Avoid recursive calls */
6471   if (tree_view->priv->in_top_row_to_dy)
6472     return;
6473
6474   if (tree_view->priv->top_row)
6475     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6476   else
6477     path = NULL;
6478
6479   if (!path)
6480     tree = NULL;
6481   else
6482     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6483
6484   if (path)
6485     gtk_tree_path_free (path);
6486
6487   if (tree == NULL)
6488     {
6489       /* keep dy and set new toprow */
6490       gtk_tree_row_reference_free (tree_view->priv->top_row);
6491       tree_view->priv->top_row = NULL;
6492       tree_view->priv->top_row_dy = 0;
6493       /* DO NOT install the idle handler */
6494       gtk_tree_view_dy_to_top_row (tree_view);
6495       return;
6496     }
6497
6498   if (ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node))
6499       < tree_view->priv->top_row_dy)
6500     {
6501       /* new top row -- do NOT install the idle handler */
6502       gtk_tree_view_dy_to_top_row (tree_view);
6503       return;
6504     }
6505
6506   new_dy = _gtk_rbtree_node_find_offset (tree, node);
6507   new_dy += tree_view->priv->top_row_dy;
6508
6509   if (new_dy + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
6510     new_dy = tree_view->priv->height - tree_view->priv->vadjustment->page_size;
6511
6512   new_dy = MAX (0, new_dy);
6513
6514   tree_view->priv->in_top_row_to_dy = TRUE;
6515   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
6516   tree_view->priv->in_top_row_to_dy = FALSE;
6517 }
6518
6519
6520 void
6521 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view)
6522 {
6523   tree_view->priv->mark_rows_col_dirty = TRUE;
6524
6525   install_presize_handler (tree_view);
6526 }
6527
6528 /*
6529  * This function works synchronously (due to the while (validate_rows...)
6530  * loop).
6531  *
6532  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
6533  * here. You now need to check that yourself.
6534  */
6535 void
6536 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
6537                                 GtkTreeViewColumn *column)
6538 {
6539   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6540   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
6541
6542   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
6543
6544   do_presize_handler (tree_view);
6545   while (validate_rows (tree_view));
6546
6547   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6548 }
6549
6550 /* Drag-and-drop */
6551
6552 static void
6553 set_source_row (GdkDragContext *context,
6554                 GtkTreeModel   *model,
6555                 GtkTreePath    *source_row)
6556 {
6557   g_object_set_data_full (G_OBJECT (context),
6558                           I_("gtk-tree-view-source-row"),
6559                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
6560                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
6561 }
6562
6563 static GtkTreePath*
6564 get_source_row (GdkDragContext *context)
6565 {
6566   GtkTreeRowReference *ref =
6567     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
6568
6569   if (ref)
6570     return gtk_tree_row_reference_get_path (ref);
6571   else
6572     return NULL;
6573 }
6574
6575 typedef struct
6576 {
6577   GtkTreeRowReference *dest_row;
6578   guint                path_down_mode   : 1;
6579   guint                empty_view_drop  : 1;
6580   guint                drop_append_mode : 1;
6581 }
6582 DestRow;
6583
6584 static void
6585 dest_row_free (gpointer data)
6586 {
6587   DestRow *dr = (DestRow *)data;
6588
6589   gtk_tree_row_reference_free (dr->dest_row);
6590   g_slice_free (DestRow, dr);
6591 }
6592
6593 static void
6594 set_dest_row (GdkDragContext *context,
6595               GtkTreeModel   *model,
6596               GtkTreePath    *dest_row,
6597               gboolean        path_down_mode,
6598               gboolean        empty_view_drop,
6599               gboolean        drop_append_mode)
6600 {
6601   DestRow *dr;
6602
6603   if (!dest_row)
6604     {
6605       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
6606                               NULL, NULL);
6607       return;
6608     }
6609
6610   dr = g_slice_new (DestRow);
6611
6612   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
6613   dr->path_down_mode = path_down_mode != FALSE;
6614   dr->empty_view_drop = empty_view_drop != FALSE;
6615   dr->drop_append_mode = drop_append_mode != FALSE;
6616
6617   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
6618                           dr, (GDestroyNotify) dest_row_free);
6619 }
6620
6621 static GtkTreePath*
6622 get_dest_row (GdkDragContext *context,
6623               gboolean       *path_down_mode)
6624 {
6625   DestRow *dr =
6626     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
6627
6628   if (dr)
6629     {
6630       GtkTreePath *path = NULL;
6631
6632       if (path_down_mode)
6633         *path_down_mode = dr->path_down_mode;
6634
6635       if (dr->dest_row)
6636         path = gtk_tree_row_reference_get_path (dr->dest_row);
6637       else if (dr->empty_view_drop)
6638         path = gtk_tree_path_new_from_indices (0, -1);
6639       else
6640         path = NULL;
6641
6642       if (path && dr->drop_append_mode)
6643         gtk_tree_path_next (path);
6644
6645       return path;
6646     }
6647   else
6648     return NULL;
6649 }
6650
6651 /* Get/set whether drag_motion requested the drag data and
6652  * drag_data_received should thus not actually insert the data,
6653  * since the data doesn't result from a drop.
6654  */
6655 static void
6656 set_status_pending (GdkDragContext *context,
6657                     GdkDragAction   suggested_action)
6658 {
6659   g_object_set_data (G_OBJECT (context),
6660                      I_("gtk-tree-view-status-pending"),
6661                      GINT_TO_POINTER (suggested_action));
6662 }
6663
6664 static GdkDragAction
6665 get_status_pending (GdkDragContext *context)
6666 {
6667   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
6668                                              "gtk-tree-view-status-pending"));
6669 }
6670
6671 static TreeViewDragInfo*
6672 get_info (GtkTreeView *tree_view)
6673 {
6674   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
6675 }
6676
6677 static void
6678 destroy_info (TreeViewDragInfo *di)
6679 {
6680   g_slice_free (TreeViewDragInfo, di);
6681 }
6682
6683 static TreeViewDragInfo*
6684 ensure_info (GtkTreeView *tree_view)
6685 {
6686   TreeViewDragInfo *di;
6687
6688   di = get_info (tree_view);
6689
6690   if (di == NULL)
6691     {
6692       di = g_slice_new0 (TreeViewDragInfo);
6693
6694       g_object_set_data_full (G_OBJECT (tree_view),
6695                               I_("gtk-tree-view-drag-info"),
6696                               di,
6697                               (GDestroyNotify) destroy_info);
6698     }
6699
6700   return di;
6701 }
6702
6703 static void
6704 remove_info (GtkTreeView *tree_view)
6705 {
6706   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
6707 }
6708
6709 #if 0
6710 static gint
6711 drag_scan_timeout (gpointer data)
6712 {
6713   GtkTreeView *tree_view;
6714   gint x, y;
6715   GdkModifierType state;
6716   GtkTreePath *path = NULL;
6717   GtkTreeViewColumn *column = NULL;
6718   GdkRectangle visible_rect;
6719
6720   GDK_THREADS_ENTER ();
6721
6722   tree_view = GTK_TREE_VIEW (data);
6723
6724   gdk_window_get_pointer (tree_view->priv->bin_window,
6725                           &x, &y, &state);
6726
6727   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
6728
6729   /* See if we are near the edge. */
6730   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
6731       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
6732       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
6733       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
6734     {
6735       gtk_tree_view_get_path_at_pos (tree_view,
6736                                      tree_view->priv->bin_window,
6737                                      x, y,
6738                                      &path,
6739                                      &column,
6740                                      NULL,
6741                                      NULL);
6742
6743       if (path != NULL)
6744         {
6745           gtk_tree_view_scroll_to_cell (tree_view,
6746                                         path,
6747                                         column,
6748                                         TRUE,
6749                                         0.5, 0.5);
6750
6751           gtk_tree_path_free (path);
6752         }
6753     }
6754
6755   GDK_THREADS_LEAVE ();
6756
6757   return TRUE;
6758 }
6759 #endif /* 0 */
6760
6761 static void
6762 add_scroll_timeout (GtkTreeView *tree_view)
6763 {
6764   if (tree_view->priv->scroll_timeout == 0)
6765     {
6766       tree_view->priv->scroll_timeout =
6767         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
6768     }
6769 }
6770
6771 static void
6772 remove_scroll_timeout (GtkTreeView *tree_view)
6773 {
6774   if (tree_view->priv->scroll_timeout != 0)
6775     {
6776       g_source_remove (tree_view->priv->scroll_timeout);
6777       tree_view->priv->scroll_timeout = 0;
6778     }
6779 }
6780
6781 static gboolean
6782 check_model_dnd (GtkTreeModel *model,
6783                  GType         required_iface,
6784                  const gchar  *signal)
6785 {
6786   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
6787     {
6788       g_warning ("You must override the default '%s' handler "
6789                  "on GtkTreeView when using models that don't support "
6790                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
6791                  "is to connect to '%s' and call "
6792                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
6793                  "the default handler from running. Look at the source code "
6794                  "for the default handler in gtktreeview.c to get an idea what "
6795                  "your handler should do. (gtktreeview.c is in the GTK source "
6796                  "code.) If you're using GTK from a language other than C, "
6797                  "there may be a more natural way to override default handlers, e.g. via derivation.",
6798                  signal, g_type_name (required_iface), signal);
6799       return FALSE;
6800     }
6801   else
6802     return TRUE;
6803 }
6804
6805 static void
6806 remove_open_timeout (GtkTreeView *tree_view)
6807 {
6808   if (tree_view->priv->open_dest_timeout != 0)
6809     {
6810       g_source_remove (tree_view->priv->open_dest_timeout);
6811       tree_view->priv->open_dest_timeout = 0;
6812     }
6813 }
6814
6815
6816 static gint
6817 open_row_timeout (gpointer data)
6818 {
6819   GtkTreeView *tree_view = data;
6820   GtkTreePath *dest_path = NULL;
6821   GtkTreeViewDropPosition pos;
6822   gboolean result = FALSE;
6823
6824   gtk_tree_view_get_drag_dest_row (tree_view,
6825                                    &dest_path,
6826                                    &pos);
6827
6828   if (dest_path &&
6829       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
6830        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
6831     {
6832       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
6833       tree_view->priv->open_dest_timeout = 0;
6834
6835       gtk_tree_path_free (dest_path);
6836     }
6837   else
6838     {
6839       if (dest_path)
6840         gtk_tree_path_free (dest_path);
6841
6842       result = TRUE;
6843     }
6844
6845   return result;
6846 }
6847
6848 static gboolean
6849 scroll_row_timeout (gpointer data)
6850 {
6851   GtkTreeView *tree_view = data;
6852
6853   gtk_tree_view_vertical_autoscroll (tree_view);
6854
6855   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
6856     gtk_tree_view_update_rubber_band (tree_view);
6857
6858   return TRUE;
6859 }
6860
6861 /* Returns TRUE if event should not be propagated to parent widgets */
6862 static gboolean
6863 set_destination_row (GtkTreeView    *tree_view,
6864                      GdkDragContext *context,
6865                      /* coordinates relative to the widget */
6866                      gint            x,
6867                      gint            y,
6868                      GdkDragAction  *suggested_action,
6869                      GdkAtom        *target)
6870 {
6871   GtkTreePath *path = NULL;
6872   GtkTreeViewDropPosition pos;
6873   GtkTreeViewDropPosition old_pos;
6874   TreeViewDragInfo *di;
6875   GtkWidget *widget;
6876   GtkTreePath *old_dest_path = NULL;
6877   gboolean can_drop = FALSE;
6878
6879   *suggested_action = 0;
6880   *target = GDK_NONE;
6881
6882   widget = GTK_WIDGET (tree_view);
6883
6884   di = get_info (tree_view);
6885
6886   if (di == NULL || y - TREE_VIEW_HEADER_HEIGHT (tree_view) < 0)
6887     {
6888       /* someone unset us as a drag dest, note that if
6889        * we return FALSE drag_leave isn't called
6890        */
6891
6892       gtk_tree_view_set_drag_dest_row (tree_view,
6893                                        NULL,
6894                                        GTK_TREE_VIEW_DROP_BEFORE);
6895
6896       remove_scroll_timeout (GTK_TREE_VIEW (widget));
6897       remove_open_timeout (GTK_TREE_VIEW (widget));
6898
6899       return FALSE; /* no longer a drop site */
6900     }
6901
6902   *target = gtk_drag_dest_find_target (widget, context,
6903                                        gtk_drag_dest_get_target_list (widget));
6904   if (*target == GDK_NONE)
6905     {
6906       return FALSE;
6907     }
6908
6909   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
6910                                           x, y,
6911                                           &path,
6912                                           &pos))
6913     {
6914       gint n_children;
6915       GtkTreeModel *model;
6916
6917       remove_open_timeout (tree_view);
6918
6919       /* the row got dropped on empty space, let's setup a special case
6920        */
6921
6922       if (path)
6923         gtk_tree_path_free (path);
6924
6925       model = gtk_tree_view_get_model (tree_view);
6926
6927       n_children = gtk_tree_model_iter_n_children (model, NULL);
6928       if (n_children)
6929         {
6930           pos = GTK_TREE_VIEW_DROP_AFTER;
6931           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
6932         }
6933       else
6934         {
6935           pos = GTK_TREE_VIEW_DROP_BEFORE;
6936           path = gtk_tree_path_new_from_indices (0, -1);
6937         }
6938
6939       can_drop = TRUE;
6940
6941       goto out;
6942     }
6943
6944   g_assert (path);
6945
6946   /* If we left the current row's "open" zone, unset the timeout for
6947    * opening the row
6948    */
6949   gtk_tree_view_get_drag_dest_row (tree_view,
6950                                    &old_dest_path,
6951                                    &old_pos);
6952
6953   if (old_dest_path &&
6954       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
6955        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
6956          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
6957     remove_open_timeout (tree_view);
6958
6959   if (old_dest_path)
6960     gtk_tree_path_free (old_dest_path);
6961
6962   if (TRUE /* FIXME if the location droppable predicate */)
6963     {
6964       can_drop = TRUE;
6965     }
6966
6967 out:
6968   if (can_drop)
6969     {
6970       GtkWidget *source_widget;
6971
6972       *suggested_action = context->suggested_action;
6973       source_widget = gtk_drag_get_source_widget (context);
6974
6975       if (source_widget == widget)
6976         {
6977           /* Default to MOVE, unless the user has
6978            * pressed ctrl or shift to affect available actions
6979            */
6980           if ((context->actions & GDK_ACTION_MOVE) != 0)
6981             *suggested_action = GDK_ACTION_MOVE;
6982         }
6983
6984       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
6985                                        path, pos);
6986     }
6987   else
6988     {
6989       /* can't drop here */
6990       remove_open_timeout (tree_view);
6991
6992       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
6993                                        NULL,
6994                                        GTK_TREE_VIEW_DROP_BEFORE);
6995     }
6996
6997   if (path)
6998     gtk_tree_path_free (path);
6999
7000   return TRUE;
7001 }
7002
7003 static GtkTreePath*
7004 get_logical_dest_row (GtkTreeView *tree_view,
7005                       gboolean    *path_down_mode,
7006                       gboolean    *drop_append_mode)
7007 {
7008   /* adjust path to point to the row the drop goes in front of */
7009   GtkTreePath *path = NULL;
7010   GtkTreeViewDropPosition pos;
7011
7012   g_return_val_if_fail (path_down_mode != NULL, NULL);
7013   g_return_val_if_fail (drop_append_mode != NULL, NULL);
7014
7015   *path_down_mode = FALSE;
7016   *drop_append_mode = 0;
7017
7018   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7019
7020   if (path == NULL)
7021     return NULL;
7022
7023   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
7024     ; /* do nothing */
7025   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
7026            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
7027     *path_down_mode = TRUE;
7028   else
7029     {
7030       GtkTreeIter iter;
7031       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
7032
7033       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
7034
7035       if (!gtk_tree_model_get_iter (model, &iter, path) ||
7036           !gtk_tree_model_iter_next (model, &iter))
7037         *drop_append_mode = 1;
7038       else
7039         {
7040           *drop_append_mode = 0;
7041           gtk_tree_path_next (path);
7042         }
7043     }
7044
7045   return path;
7046 }
7047
7048 static gboolean
7049 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
7050                                         GdkEventMotion   *event)
7051 {
7052   GtkWidget *widget = GTK_WIDGET (tree_view);
7053   GdkDragContext *context;
7054   TreeViewDragInfo *di;
7055   GtkTreePath *path = NULL;
7056   gint button;
7057   gint cell_x, cell_y;
7058   GtkTreeModel *model;
7059   gboolean retval = FALSE;
7060
7061   di = get_info (tree_view);
7062
7063   if (di == NULL || !di->source_set)
7064     goto out;
7065
7066   if (tree_view->priv->pressed_button < 0)
7067     goto out;
7068
7069   if (!gtk_drag_check_threshold (widget,
7070                                  tree_view->priv->press_start_x,
7071                                  tree_view->priv->press_start_y,
7072                                  event->x, event->y))
7073     goto out;
7074
7075   model = gtk_tree_view_get_model (tree_view);
7076
7077   if (model == NULL)
7078     goto out;
7079
7080   button = tree_view->priv->pressed_button;
7081   tree_view->priv->pressed_button = -1;
7082
7083   gtk_tree_view_get_path_at_pos (tree_view,
7084                                  tree_view->priv->press_start_x,
7085                                  tree_view->priv->press_start_y,
7086                                  &path,
7087                                  NULL,
7088                                  &cell_x,
7089                                  &cell_y);
7090
7091   if (path == NULL)
7092     goto out;
7093
7094   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7095       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7096                                            path))
7097     goto out;
7098
7099   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7100     goto out;
7101
7102   /* Now we can begin the drag */
7103
7104   retval = TRUE;
7105
7106   context = gtk_drag_begin (widget,
7107                             gtk_drag_source_get_target_list (widget),
7108                             di->source_actions,
7109                             button,
7110                             (GdkEvent*)event);
7111
7112   set_source_row (context, model, path);
7113
7114  out:
7115   if (path)
7116     gtk_tree_path_free (path);
7117
7118   return retval;
7119 }
7120
7121
7122 static void
7123 gtk_tree_view_drag_begin (GtkWidget      *widget,
7124                           GdkDragContext *context)
7125 {
7126   GtkTreeView *tree_view;
7127   GtkTreePath *path = NULL;
7128   gint cell_x, cell_y;
7129   GdkPixmap *row_pix;
7130   TreeViewDragInfo *di;
7131
7132   tree_view = GTK_TREE_VIEW (widget);
7133
7134   /* if the user uses a custom DND source impl, we don't set the icon here */
7135   di = get_info (tree_view);
7136
7137   if (di == NULL || !di->source_set)
7138     return;
7139
7140   gtk_tree_view_get_path_at_pos (tree_view,
7141                                  tree_view->priv->press_start_x,
7142                                  tree_view->priv->press_start_y,
7143                                  &path,
7144                                  NULL,
7145                                  &cell_x,
7146                                  &cell_y);
7147
7148   g_return_if_fail (path != NULL);
7149
7150   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7151                                                 path);
7152
7153   gtk_drag_set_icon_pixmap (context,
7154                             gdk_drawable_get_colormap (row_pix),
7155                             row_pix,
7156                             NULL,
7157                             /* the + 1 is for the black border in the icon */
7158                             tree_view->priv->press_start_x + 1,
7159                             cell_y + 1);
7160
7161   g_object_unref (row_pix);
7162   gtk_tree_path_free (path);
7163 }
7164
7165 static void
7166 gtk_tree_view_drag_end (GtkWidget      *widget,
7167                         GdkDragContext *context)
7168 {
7169   /* do nothing */
7170 }
7171
7172 /* Default signal implementations for the drag signals */
7173 static void
7174 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7175                              GdkDragContext   *context,
7176                              GtkSelectionData *selection_data,
7177                              guint             info,
7178                              guint             time)
7179 {
7180   GtkTreeView *tree_view;
7181   GtkTreeModel *model;
7182   TreeViewDragInfo *di;
7183   GtkTreePath *source_row;
7184
7185   tree_view = GTK_TREE_VIEW (widget);
7186
7187   model = gtk_tree_view_get_model (tree_view);
7188
7189   if (model == NULL)
7190     return;
7191
7192   di = get_info (GTK_TREE_VIEW (widget));
7193
7194   if (di == NULL)
7195     return;
7196
7197   source_row = get_source_row (context);
7198
7199   if (source_row == NULL)
7200     return;
7201
7202   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7203    * any model; for DragSource models there are some other targets
7204    * we also support.
7205    */
7206
7207   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7208       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7209                                           source_row,
7210                                           selection_data))
7211     goto done;
7212
7213   /* If drag_data_get does nothing, try providing row data. */
7214   if (selection_data->target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7215     {
7216       gtk_tree_set_row_drag_data (selection_data,
7217                                   model,
7218                                   source_row);
7219     }
7220
7221  done:
7222   gtk_tree_path_free (source_row);
7223 }
7224
7225
7226 static void
7227 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7228                                 GdkDragContext *context)
7229 {
7230   TreeViewDragInfo *di;
7231   GtkTreeModel *model;
7232   GtkTreeView *tree_view;
7233   GtkTreePath *source_row;
7234
7235   tree_view = GTK_TREE_VIEW (widget);
7236   model = gtk_tree_view_get_model (tree_view);
7237
7238   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7239     return;
7240
7241   di = get_info (tree_view);
7242
7243   if (di == NULL)
7244     return;
7245
7246   source_row = get_source_row (context);
7247
7248   if (source_row == NULL)
7249     return;
7250
7251   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7252                                          source_row);
7253
7254   gtk_tree_path_free (source_row);
7255
7256   set_source_row (context, NULL, NULL);
7257 }
7258
7259 static void
7260 gtk_tree_view_drag_leave (GtkWidget      *widget,
7261                           GdkDragContext *context,
7262                           guint             time)
7263 {
7264   /* unset any highlight row */
7265   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7266                                    NULL,
7267                                    GTK_TREE_VIEW_DROP_BEFORE);
7268
7269   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7270   remove_open_timeout (GTK_TREE_VIEW (widget));
7271 }
7272
7273
7274 static gboolean
7275 gtk_tree_view_drag_motion (GtkWidget        *widget,
7276                            GdkDragContext   *context,
7277                            /* coordinates relative to the widget */
7278                            gint              x,
7279                            gint              y,
7280                            guint             time)
7281 {
7282   gboolean empty;
7283   GtkTreePath *path = NULL;
7284   GtkTreeViewDropPosition pos;
7285   GtkTreeView *tree_view;
7286   GdkDragAction suggested_action = 0;
7287   GdkAtom target;
7288
7289   tree_view = GTK_TREE_VIEW (widget);
7290
7291   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7292     return FALSE;
7293
7294   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7295
7296   /* we only know this *after* set_desination_row */
7297   empty = tree_view->priv->empty_view_drop;
7298
7299   if (path == NULL && !empty)
7300     {
7301       /* Can't drop here. */
7302       gdk_drag_status (context, 0, time);
7303     }
7304   else
7305     {
7306       if (tree_view->priv->open_dest_timeout == 0 &&
7307           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7308            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7309         {
7310           tree_view->priv->open_dest_timeout =
7311             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7312         }
7313       else
7314         {
7315           add_scroll_timeout (tree_view);
7316         }
7317
7318       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7319         {
7320           /* Request data so we can use the source row when
7321            * determining whether to accept the drop
7322            */
7323           set_status_pending (context, suggested_action);
7324           gtk_drag_get_data (widget, context, target, time);
7325         }
7326       else
7327         {
7328           set_status_pending (context, 0);
7329           gdk_drag_status (context, suggested_action, time);
7330         }
7331     }
7332
7333   if (path)
7334     gtk_tree_path_free (path);
7335
7336   return TRUE;
7337 }
7338
7339
7340 static gboolean
7341 gtk_tree_view_drag_drop (GtkWidget        *widget,
7342                          GdkDragContext   *context,
7343                          /* coordinates relative to the widget */
7344                          gint              x,
7345                          gint              y,
7346                          guint             time)
7347 {
7348   GtkTreeView *tree_view;
7349   GtkTreePath *path;
7350   GdkDragAction suggested_action = 0;
7351   GdkAtom target = GDK_NONE;
7352   TreeViewDragInfo *di;
7353   GtkTreeModel *model;
7354   gboolean path_down_mode;
7355   gboolean drop_append_mode;
7356
7357   tree_view = GTK_TREE_VIEW (widget);
7358
7359   model = gtk_tree_view_get_model (tree_view);
7360
7361   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7362   remove_open_timeout (GTK_TREE_VIEW (widget));
7363
7364   di = get_info (tree_view);
7365
7366   if (di == NULL)
7367     return FALSE;
7368
7369   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7370     return FALSE;
7371
7372   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7373     return FALSE;
7374
7375   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7376
7377   if (target != GDK_NONE && path != NULL)
7378     {
7379       /* in case a motion had requested drag data, change things so we
7380        * treat drag data receives as a drop.
7381        */
7382       set_status_pending (context, 0);
7383       set_dest_row (context, model, path,
7384                     path_down_mode, tree_view->priv->empty_view_drop,
7385                     drop_append_mode);
7386     }
7387
7388   if (path)
7389     gtk_tree_path_free (path);
7390
7391   /* Unset this thing */
7392   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7393                                    NULL,
7394                                    GTK_TREE_VIEW_DROP_BEFORE);
7395
7396   if (target != GDK_NONE)
7397     {
7398       gtk_drag_get_data (widget, context, target, time);
7399       return TRUE;
7400     }
7401   else
7402     return FALSE;
7403 }
7404
7405 static void
7406 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7407                                   GdkDragContext   *context,
7408                                   /* coordinates relative to the widget */
7409                                   gint              x,
7410                                   gint              y,
7411                                   GtkSelectionData *selection_data,
7412                                   guint             info,
7413                                   guint             time)
7414 {
7415   GtkTreePath *path;
7416   TreeViewDragInfo *di;
7417   gboolean accepted = FALSE;
7418   GtkTreeModel *model;
7419   GtkTreeView *tree_view;
7420   GtkTreePath *dest_row;
7421   GdkDragAction suggested_action;
7422   gboolean path_down_mode;
7423   gboolean drop_append_mode;
7424
7425   tree_view = GTK_TREE_VIEW (widget);
7426
7427   model = gtk_tree_view_get_model (tree_view);
7428
7429   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7430     return;
7431
7432   di = get_info (tree_view);
7433
7434   if (di == NULL)
7435     return;
7436
7437   suggested_action = get_status_pending (context);
7438
7439   if (suggested_action)
7440     {
7441       /* We are getting this data due to a request in drag_motion,
7442        * rather than due to a request in drag_drop, so we are just
7443        * supposed to call drag_status, not actually paste in the
7444        * data.
7445        */
7446       path = get_logical_dest_row (tree_view, &path_down_mode,
7447                                    &drop_append_mode);
7448
7449       if (path == NULL)
7450         suggested_action = 0;
7451       else if (path_down_mode)
7452         gtk_tree_path_down (path);
7453
7454       if (suggested_action)
7455         {
7456           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7457                                                      path,
7458                                                      selection_data))
7459             {
7460               if (path_down_mode)
7461                 {
7462                   path_down_mode = FALSE;
7463                   gtk_tree_path_up (path);
7464
7465                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7466                                                              path,
7467                                                              selection_data))
7468                     suggested_action = 0;
7469                 }
7470               else
7471                 suggested_action = 0;
7472             }
7473         }
7474
7475       gdk_drag_status (context, suggested_action, time);
7476
7477       if (path)
7478         gtk_tree_path_free (path);
7479
7480       /* If you can't drop, remove user drop indicator until the next motion */
7481       if (suggested_action == 0)
7482         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7483                                          NULL,
7484                                          GTK_TREE_VIEW_DROP_BEFORE);
7485
7486       return;
7487     }
7488
7489   dest_row = get_dest_row (context, &path_down_mode);
7490
7491   if (dest_row == NULL)
7492     return;
7493
7494   if (selection_data->length >= 0)
7495     {
7496       if (path_down_mode)
7497         {
7498           gtk_tree_path_down (dest_row);
7499           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7500                                                      dest_row, selection_data))
7501             gtk_tree_path_up (dest_row);
7502         }
7503     }
7504
7505   if (selection_data->length >= 0)
7506     {
7507       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
7508                                                  dest_row,
7509                                                  selection_data))
7510         accepted = TRUE;
7511     }
7512
7513   gtk_drag_finish (context,
7514                    accepted,
7515                    (context->action == GDK_ACTION_MOVE),
7516                    time);
7517
7518   if (gtk_tree_path_get_depth (dest_row) == 1
7519       && gtk_tree_path_get_indices (dest_row)[0] == 0)
7520     {
7521       /* special special case drag to "0", scroll to first item */
7522       if (!tree_view->priv->scroll_to_path)
7523         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
7524     }
7525
7526   gtk_tree_path_free (dest_row);
7527
7528   /* drop dest_row */
7529   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
7530 }
7531
7532
7533
7534 /* GtkContainer Methods
7535  */
7536
7537
7538 static void
7539 gtk_tree_view_remove (GtkContainer *container,
7540                       GtkWidget    *widget)
7541 {
7542   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7543   GtkTreeViewChild *child = NULL;
7544   GList *tmp_list;
7545
7546   tmp_list = tree_view->priv->children;
7547   while (tmp_list)
7548     {
7549       child = tmp_list->data;
7550       if (child->widget == widget)
7551         {
7552           gtk_widget_unparent (widget);
7553
7554           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
7555           g_list_free_1 (tmp_list);
7556           g_slice_free (GtkTreeViewChild, child);
7557           return;
7558         }
7559
7560       tmp_list = tmp_list->next;
7561     }
7562
7563   tmp_list = tree_view->priv->columns;
7564
7565   while (tmp_list)
7566     {
7567       GtkTreeViewColumn *column;
7568       column = tmp_list->data;
7569       if (column->button == widget)
7570         {
7571           gtk_widget_unparent (widget);
7572           return;
7573         }
7574       tmp_list = tmp_list->next;
7575     }
7576 }
7577
7578 static void
7579 gtk_tree_view_forall (GtkContainer *container,
7580                       gboolean      include_internals,
7581                       GtkCallback   callback,
7582                       gpointer      callback_data)
7583 {
7584   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7585   GtkTreeViewChild *child = NULL;
7586   GtkTreeViewColumn *column;
7587   GList *tmp_list;
7588
7589   tmp_list = tree_view->priv->children;
7590   while (tmp_list)
7591     {
7592       child = tmp_list->data;
7593       tmp_list = tmp_list->next;
7594
7595       (* callback) (child->widget, callback_data);
7596     }
7597   if (include_internals == FALSE)
7598     return;
7599
7600   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
7601     {
7602       column = tmp_list->data;
7603
7604       if (column->button)
7605         (* callback) (column->button, callback_data);
7606     }
7607 }
7608
7609 /* Returns TRUE if the treeview contains no "special" (editable or activatable)
7610  * cells. If so we draw one big row-spanning focus rectangle.
7611  */
7612 static gboolean
7613 gtk_tree_view_has_special_cell (GtkTreeView *tree_view)
7614 {
7615   GList *list;
7616
7617   for (list = tree_view->priv->columns; list; list = list->next)
7618     {
7619       if (!((GtkTreeViewColumn *)list->data)->visible)
7620         continue;
7621       if (_gtk_tree_view_column_count_special_cells (list->data))
7622         return TRUE;
7623     }
7624
7625   return FALSE;
7626 }
7627
7628 static void
7629 column_sizing_notify (GObject    *object,
7630                       GParamSpec *pspec,
7631                       gpointer    data)
7632 {
7633   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
7634
7635   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
7636     /* disable fixed height mode */
7637     g_object_set (data, "fixed-height-mode", FALSE, NULL);
7638 }
7639
7640 /**
7641  * gtk_tree_view_set_fixed_height_mode:
7642  * @tree_view: a #GtkTreeView
7643  * @enable: %TRUE to enable fixed height mode
7644  *
7645  * Enables or disables the fixed height mode of @tree_view.
7646  * Fixed height mode speeds up #GtkTreeView by assuming that all
7647  * rows have the same height.
7648  * Only enable this option if all rows are the same height and all
7649  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
7650  *
7651  * Since: 2.6
7652  **/
7653 void
7654 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
7655                                      gboolean     enable)
7656 {
7657   GList *l;
7658
7659   enable = enable != FALSE;
7660
7661   if (enable == tree_view->priv->fixed_height_mode)
7662     return;
7663
7664   if (!enable)
7665     {
7666       tree_view->priv->fixed_height_mode = 0;
7667       tree_view->priv->fixed_height = -1;
7668
7669       /* force a revalidation */
7670       install_presize_handler (tree_view);
7671     }
7672   else
7673     {
7674       /* make sure all columns are of type FIXED */
7675       for (l = tree_view->priv->columns; l; l = l->next)
7676         {
7677           GtkTreeViewColumn *c = l->data;
7678
7679           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
7680         }
7681
7682       /* yes, we really have to do this is in a separate loop */
7683       for (l = tree_view->priv->columns; l; l = l->next)
7684         g_signal_connect (l->data, "notify::sizing",
7685                           G_CALLBACK (column_sizing_notify), tree_view);
7686
7687       tree_view->priv->fixed_height_mode = 1;
7688       tree_view->priv->fixed_height = -1;
7689
7690       if (tree_view->priv->tree)
7691         initialize_fixed_height_mode (tree_view);
7692     }
7693
7694   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
7695 }
7696
7697 /**
7698  * gtk_tree_view_get_fixed_height_mode:
7699  * @tree_view: a #GtkTreeView
7700  *
7701  * Returns whether fixed height mode is turned on for @tree_view.
7702  *
7703  * Return value: %TRUE if @tree_view is in fixed height mode
7704  *
7705  * Since: 2.6
7706  **/
7707 gboolean
7708 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
7709 {
7710   return tree_view->priv->fixed_height_mode;
7711 }
7712
7713 /* Returns TRUE if the focus is within the headers, after the focus operation is
7714  * done
7715  */
7716 static gboolean
7717 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
7718                             GtkDirectionType  dir,
7719                             gboolean          clamp_column_visible)
7720 {
7721   GtkWidget *focus_child;
7722
7723   GList *last_column, *first_column;
7724   GList *tmp_list;
7725   gboolean rtl;
7726
7727   if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
7728     return FALSE;
7729
7730   focus_child = GTK_CONTAINER (tree_view)->focus_child;
7731
7732   first_column = tree_view->priv->columns;
7733   while (first_column)
7734     {
7735       if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (first_column->data)->button) &&
7736           GTK_TREE_VIEW_COLUMN (first_column->data)->visible &&
7737           (GTK_TREE_VIEW_COLUMN (first_column->data)->clickable ||
7738            GTK_TREE_VIEW_COLUMN (first_column->data)->reorderable))
7739         break;
7740       first_column = first_column->next;
7741     }
7742
7743   /* No headers are visible, or are focusable.  We can't focus in or out.
7744    */
7745   if (first_column == NULL)
7746     return FALSE;
7747
7748   last_column = g_list_last (tree_view->priv->columns);
7749   while (last_column)
7750     {
7751       if (GTK_WIDGET_CAN_FOCUS (GTK_TREE_VIEW_COLUMN (last_column->data)->button) &&
7752           GTK_TREE_VIEW_COLUMN (last_column->data)->visible &&
7753           (GTK_TREE_VIEW_COLUMN (last_column->data)->clickable ||
7754            GTK_TREE_VIEW_COLUMN (last_column->data)->reorderable))
7755         break;
7756       last_column = last_column->prev;
7757     }
7758
7759
7760   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
7761
7762   switch (dir)
7763     {
7764     case GTK_DIR_TAB_BACKWARD:
7765     case GTK_DIR_TAB_FORWARD:
7766     case GTK_DIR_UP:
7767     case GTK_DIR_DOWN:
7768       if (focus_child == NULL)
7769         {
7770           if (tree_view->priv->focus_column != NULL && GTK_WIDGET_CAN_FOCUS (tree_view->priv->focus_column->button))
7771             focus_child = tree_view->priv->focus_column->button;
7772           else
7773             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
7774           gtk_widget_grab_focus (focus_child);
7775           break;
7776         }
7777       return FALSE;
7778
7779     case GTK_DIR_LEFT:
7780     case GTK_DIR_RIGHT:
7781       if (focus_child == NULL)
7782         {
7783           if (tree_view->priv->focus_column != NULL)
7784             focus_child = tree_view->priv->focus_column->button;
7785           else if (dir == GTK_DIR_LEFT)
7786             focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
7787           else
7788             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
7789           gtk_widget_grab_focus (focus_child);
7790           break;
7791         }
7792
7793       if (gtk_widget_child_focus (focus_child, dir))
7794         {
7795           /* The focus moves inside the button. */
7796           /* This is probably a great example of bad UI */
7797           break;
7798         }
7799
7800       /* We need to move the focus among the row of buttons. */
7801       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
7802         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
7803           break;
7804
7805       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
7806           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
7807         {
7808           gtk_widget_error_bell (GTK_WIDGET (tree_view));
7809           break;
7810         }
7811
7812       while (tmp_list)
7813         {
7814           GtkTreeViewColumn *column;
7815
7816           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
7817             tmp_list = tmp_list->next;
7818           else
7819             tmp_list = tmp_list->prev;
7820
7821           if (tmp_list == NULL)
7822             {
7823               g_warning ("Internal button not found");
7824               break;
7825             }
7826           column = tmp_list->data;
7827           if (column->button &&
7828               column->visible &&
7829               GTK_WIDGET_CAN_FOCUS (column->button))
7830             {
7831               focus_child = column->button;
7832               gtk_widget_grab_focus (column->button);
7833               break;
7834             }
7835         }
7836       break;
7837     default:
7838       g_assert_not_reached ();
7839       break;
7840     }
7841
7842   /* if focus child is non-null, we assume it's been set to the current focus child
7843    */
7844   if (focus_child)
7845     {
7846       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
7847         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
7848           {
7849             tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
7850             break;
7851           }
7852
7853       if (clamp_column_visible)
7854         {
7855           gtk_tree_view_clamp_column_visible (tree_view,
7856                                               tree_view->priv->focus_column,
7857                                               FALSE);
7858         }
7859     }
7860
7861   return (focus_child != NULL);
7862 }
7863
7864 /* This function returns in 'path' the first focusable path, if the given path
7865  * is already focusable, it's the returned one.
7866  */
7867 static gboolean
7868 search_first_focusable_path (GtkTreeView  *tree_view,
7869                              GtkTreePath **path,
7870                              gboolean      search_forward,
7871                              GtkRBTree   **new_tree,
7872                              GtkRBNode   **new_node)
7873 {
7874   GtkRBTree *tree = NULL;
7875   GtkRBNode *node = NULL;
7876
7877   if (!path || !*path)
7878     return FALSE;
7879
7880   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
7881
7882   if (!tree || !node)
7883     return FALSE;
7884
7885   while (node && row_is_separator (tree_view, NULL, *path))
7886     {
7887       if (search_forward)
7888         _gtk_rbtree_next_full (tree, node, &tree, &node);
7889       else
7890         _gtk_rbtree_prev_full (tree, node, &tree, &node);
7891
7892       if (*path)
7893         gtk_tree_path_free (*path);
7894
7895       if (node)
7896         *path = _gtk_tree_view_find_path (tree_view, tree, node);
7897       else
7898         *path = NULL;
7899     }
7900
7901   if (new_tree)
7902     *new_tree = tree;
7903
7904   if (new_node)
7905     *new_node = node;
7906
7907   return (*path != NULL);
7908 }
7909
7910 static gint
7911 gtk_tree_view_focus (GtkWidget        *widget,
7912                      GtkDirectionType  direction)
7913 {
7914   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
7915   GtkContainer *container = GTK_CONTAINER (widget);
7916   GtkWidget *focus_child;
7917
7918   if (!GTK_WIDGET_IS_SENSITIVE (container) || !GTK_WIDGET_CAN_FOCUS (widget))
7919     return FALSE;
7920
7921   focus_child = container->focus_child;
7922
7923   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
7924   /* Case 1.  Headers currently have focus. */
7925   if (focus_child)
7926     {
7927       switch (direction)
7928         {
7929         case GTK_DIR_LEFT:
7930         case GTK_DIR_RIGHT:
7931           gtk_tree_view_header_focus (tree_view, direction, TRUE);
7932           return TRUE;
7933         case GTK_DIR_TAB_BACKWARD:
7934         case GTK_DIR_UP:
7935           return FALSE;
7936         case GTK_DIR_TAB_FORWARD:
7937         case GTK_DIR_DOWN:
7938           gtk_widget_grab_focus (widget);
7939           return TRUE;
7940         default:
7941           g_assert_not_reached ();
7942           return FALSE;
7943         }
7944     }
7945
7946   /* Case 2. We don't have focus at all. */
7947   if (!GTK_WIDGET_HAS_FOCUS (container))
7948     {
7949       if (!gtk_tree_view_header_focus (tree_view, direction, FALSE))
7950         gtk_widget_grab_focus (widget);
7951       return TRUE;
7952     }
7953
7954   /* Case 3. We have focus already. */
7955   if (direction == GTK_DIR_TAB_BACKWARD)
7956     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
7957   else if (direction == GTK_DIR_TAB_FORWARD)
7958     return FALSE;
7959
7960   /* Other directions caught by the keybindings */
7961   gtk_widget_grab_focus (widget);
7962   return TRUE;
7963 }
7964
7965 static void
7966 gtk_tree_view_grab_focus (GtkWidget *widget)
7967 {
7968   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
7969
7970   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
7971 }
7972
7973 static void
7974 gtk_tree_view_style_set (GtkWidget *widget,
7975                          GtkStyle *previous_style)
7976 {
7977   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
7978   GList *list;
7979   GtkTreeViewColumn *column;
7980
7981   if (GTK_WIDGET_REALIZED (widget))
7982     {
7983       gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
7984       gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
7985       gtk_style_set_background (widget->style, tree_view->priv->header_window, GTK_STATE_NORMAL);
7986
7987       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
7988       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
7989     }
7990
7991   gtk_widget_style_get (widget,
7992                         "expander-size", &tree_view->priv->expander_size,
7993                         NULL);
7994   tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
7995
7996   for (list = tree_view->priv->columns; list; list = list->next)
7997     {
7998       column = list->data;
7999       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8000     }
8001
8002   tree_view->priv->fixed_height = -1;
8003   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
8004
8005   gtk_widget_queue_resize (widget);
8006 }
8007
8008
8009 static void
8010 gtk_tree_view_set_focus_child (GtkContainer *container,
8011                                GtkWidget    *child)
8012 {
8013   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8014   GList *list;
8015
8016   for (list = tree_view->priv->columns; list; list = list->next)
8017     {
8018       if (GTK_TREE_VIEW_COLUMN (list->data)->button == child)
8019         {
8020           tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
8021           break;
8022         }
8023     }
8024
8025   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
8026 }
8027
8028 static void
8029 gtk_tree_view_set_adjustments (GtkTreeView   *tree_view,
8030                                GtkAdjustment *hadj,
8031                                GtkAdjustment *vadj)
8032 {
8033   gboolean need_adjust = FALSE;
8034
8035   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8036
8037   if (hadj)
8038     g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
8039   else
8040     hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
8041   if (vadj)
8042     g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
8043   else
8044     vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
8045
8046   if (tree_view->priv->hadjustment && (tree_view->priv->hadjustment != hadj))
8047     {
8048       g_signal_handlers_disconnect_by_func (tree_view->priv->hadjustment,
8049                                             gtk_tree_view_adjustment_changed,
8050                                             tree_view);
8051       g_object_unref (tree_view->priv->hadjustment);
8052     }
8053
8054   if (tree_view->priv->vadjustment && (tree_view->priv->vadjustment != vadj))
8055     {
8056       g_signal_handlers_disconnect_by_func (tree_view->priv->vadjustment,
8057                                             gtk_tree_view_adjustment_changed,
8058                                             tree_view);
8059       g_object_unref (tree_view->priv->vadjustment);
8060     }
8061
8062   if (tree_view->priv->hadjustment != hadj)
8063     {
8064       tree_view->priv->hadjustment = hadj;
8065       g_object_ref_sink (tree_view->priv->hadjustment);
8066
8067       g_signal_connect (tree_view->priv->hadjustment, "value-changed",
8068                         G_CALLBACK (gtk_tree_view_adjustment_changed),
8069                         tree_view);
8070       need_adjust = TRUE;
8071     }
8072
8073   if (tree_view->priv->vadjustment != vadj)
8074     {
8075       tree_view->priv->vadjustment = vadj;
8076       g_object_ref_sink (tree_view->priv->vadjustment);
8077
8078       g_signal_connect (tree_view->priv->vadjustment, "value-changed",
8079                         G_CALLBACK (gtk_tree_view_adjustment_changed),
8080                         tree_view);
8081       need_adjust = TRUE;
8082     }
8083
8084   if (need_adjust)
8085     gtk_tree_view_adjustment_changed (NULL, tree_view);
8086 }
8087
8088
8089 static gboolean
8090 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8091                                 GtkMovementStep    step,
8092                                 gint               count)
8093 {
8094   GdkModifierType state;
8095
8096   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8097   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8098                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8099                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8100                         step == GTK_MOVEMENT_PAGES ||
8101                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8102
8103   if (tree_view->priv->tree == NULL)
8104     return FALSE;
8105   if (!GTK_WIDGET_HAS_FOCUS (GTK_WIDGET (tree_view)))
8106     return FALSE;
8107
8108   gtk_tree_view_stop_editing (tree_view, FALSE);
8109   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
8110   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8111
8112   if (gtk_get_current_event_state (&state))
8113     {
8114       if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
8115         tree_view->priv->ctrl_pressed = TRUE;
8116       if ((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
8117         tree_view->priv->shift_pressed = TRUE;
8118     }
8119   /* else we assume not pressed */
8120
8121   switch (step)
8122     {
8123       /* currently we make no distinction.  When we go bi-di, we need to */
8124     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8125     case GTK_MOVEMENT_VISUAL_POSITIONS:
8126       gtk_tree_view_move_cursor_left_right (tree_view, count);
8127       break;
8128     case GTK_MOVEMENT_DISPLAY_LINES:
8129       gtk_tree_view_move_cursor_up_down (tree_view, count);
8130       break;
8131     case GTK_MOVEMENT_PAGES:
8132       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8133       break;
8134     case GTK_MOVEMENT_BUFFER_ENDS:
8135       gtk_tree_view_move_cursor_start_end (tree_view, count);
8136       break;
8137     default:
8138       g_assert_not_reached ();
8139     }
8140
8141   tree_view->priv->ctrl_pressed = FALSE;
8142   tree_view->priv->shift_pressed = FALSE;
8143
8144   return TRUE;
8145 }
8146
8147 static void
8148 gtk_tree_view_put (GtkTreeView *tree_view,
8149                    GtkWidget   *child_widget,
8150                    /* in bin_window coordinates */
8151                    gint         x,
8152                    gint         y,
8153                    gint         width,
8154                    gint         height)
8155 {
8156   GtkTreeViewChild *child;
8157
8158   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8159   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8160
8161   child = g_slice_new (GtkTreeViewChild);
8162
8163   child->widget = child_widget;
8164   child->x = x;
8165   child->y = y;
8166   child->width = width;
8167   child->height = height;
8168
8169   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8170
8171   if (GTK_WIDGET_REALIZED (tree_view))
8172     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8173
8174   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8175 }
8176
8177 void
8178 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8179                                   GtkWidget   *widget,
8180                                   /* in tree coordinates */
8181                                   gint         x,
8182                                   gint         y,
8183                                   gint         width,
8184                                   gint         height)
8185 {
8186   GtkTreeViewChild *child = NULL;
8187   GList *list;
8188   GdkRectangle allocation;
8189
8190   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8191   g_return_if_fail (GTK_IS_WIDGET (widget));
8192
8193   for (list = tree_view->priv->children; list; list = list->next)
8194     {
8195       if (((GtkTreeViewChild *)list->data)->widget == widget)
8196         {
8197           child = list->data;
8198           break;
8199         }
8200     }
8201   if (child == NULL)
8202     return;
8203
8204   allocation.x = child->x = x;
8205   allocation.y = child->y = y;
8206   allocation.width = child->width = width;
8207   allocation.height = child->height = height;
8208
8209   if (GTK_WIDGET_REALIZED (widget))
8210     gtk_widget_size_allocate (widget, &allocation);
8211 }
8212
8213
8214 /* TreeModel Callbacks
8215  */
8216
8217 static void
8218 gtk_tree_view_row_changed (GtkTreeModel *model,
8219                            GtkTreePath  *path,
8220                            GtkTreeIter  *iter,
8221                            gpointer      data)
8222 {
8223   GtkTreeView *tree_view = (GtkTreeView *)data;
8224   GtkRBTree *tree;
8225   GtkRBNode *node;
8226   gboolean free_path = FALSE;
8227   GList *list;
8228   GtkTreePath *cursor_path;
8229
8230   g_return_if_fail (path != NULL || iter != NULL);
8231
8232   if (tree_view->priv->cursor != NULL)
8233     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8234   else
8235     cursor_path = NULL;
8236
8237   if (tree_view->priv->edited_column &&
8238       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8239     gtk_tree_view_stop_editing (tree_view, TRUE);
8240
8241   if (cursor_path != NULL)
8242     gtk_tree_path_free (cursor_path);
8243
8244   if (path == NULL)
8245     {
8246       path = gtk_tree_model_get_path (model, iter);
8247       free_path = TRUE;
8248     }
8249   else if (iter == NULL)
8250     gtk_tree_model_get_iter (model, iter, path);
8251
8252   if (_gtk_tree_view_find_node (tree_view,
8253                                 path,
8254                                 &tree,
8255                                 &node))
8256     /* We aren't actually showing the node */
8257     goto done;
8258
8259   if (tree == NULL)
8260     goto done;
8261
8262   if (tree_view->priv->fixed_height_mode
8263       && tree_view->priv->fixed_height >= 0)
8264     {
8265       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8266       if (GTK_WIDGET_REALIZED (tree_view))
8267         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8268     }
8269   else
8270     {
8271       _gtk_rbtree_node_mark_invalid (tree, node);
8272       for (list = tree_view->priv->columns; list; list = list->next)
8273         {
8274           GtkTreeViewColumn *column;
8275
8276           column = list->data;
8277           if (! column->visible)
8278             continue;
8279
8280           if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8281             {
8282               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8283             }
8284         }
8285     }
8286
8287  done:
8288   if (GTK_WIDGET_REALIZED (tree_view) && !tree_view->priv->fixed_height_mode)
8289     install_presize_handler (tree_view);
8290   if (free_path)
8291     gtk_tree_path_free (path);
8292 }
8293
8294 static void
8295 gtk_tree_view_row_inserted (GtkTreeModel *model,
8296                             GtkTreePath  *path,
8297                             GtkTreeIter  *iter,
8298                             gpointer      data)
8299 {
8300   GtkTreeView *tree_view = (GtkTreeView *) data;
8301   gint *indices;
8302   GtkRBTree *tmptree, *tree;
8303   GtkRBNode *tmpnode = NULL;
8304   gint depth;
8305   gint i = 0;
8306   gint height;
8307   gboolean free_path = FALSE;
8308   gboolean node_visible = TRUE;
8309
8310   g_return_if_fail (path != NULL || iter != NULL);
8311
8312   if (tree_view->priv->fixed_height_mode
8313       && tree_view->priv->fixed_height >= 0)
8314     height = tree_view->priv->fixed_height;
8315   else
8316     height = 0;
8317
8318   if (path == NULL)
8319     {
8320       path = gtk_tree_model_get_path (model, iter);
8321       free_path = TRUE;
8322     }
8323   else if (iter == NULL)
8324     gtk_tree_model_get_iter (model, iter, path);
8325
8326   if (tree_view->priv->tree == NULL)
8327     tree_view->priv->tree = _gtk_rbtree_new ();
8328
8329   tmptree = tree = tree_view->priv->tree;
8330
8331   /* Update all row-references */
8332   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8333   depth = gtk_tree_path_get_depth (path);
8334   indices = gtk_tree_path_get_indices (path);
8335
8336   /* First, find the parent tree */
8337   while (i < depth - 1)
8338     {
8339       if (tmptree == NULL)
8340         {
8341           /* We aren't showing the node */
8342           node_visible = FALSE;
8343           goto done;
8344         }
8345
8346       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
8347       if (tmpnode == NULL)
8348         {
8349           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8350                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8351                      "before the parent was inserted.");
8352           goto done;
8353         }
8354       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8355         {
8356           /* FIXME enforce correct behavior on model, probably */
8357           /* In theory, the model should have emitted has_child_toggled here.  We
8358            * try to catch it anyway, just to be safe, in case the model hasn't.
8359            */
8360           GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
8361                                                            tree,
8362                                                            tmpnode);
8363           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8364           gtk_tree_path_free (tmppath);
8365           goto done;
8366         }
8367
8368       tmptree = tmpnode->children;
8369       tree = tmptree;
8370       i++;
8371     }
8372
8373   if (tree == NULL)
8374     {
8375       node_visible = FALSE;
8376       goto done;
8377     }
8378
8379   /* ref the node */
8380   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8381   if (indices[depth - 1] == 0)
8382     {
8383       tmpnode = _gtk_rbtree_find_count (tree, 1);
8384       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8385     }
8386   else
8387     {
8388       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8389       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8390     }
8391
8392  done:
8393   if (height > 0)
8394     {
8395       if (tree)
8396         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8397
8398       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8399         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8400       else
8401         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8402     }
8403   else
8404     install_presize_handler (tree_view);
8405   if (free_path)
8406     gtk_tree_path_free (path);
8407 }
8408
8409 static void
8410 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8411                                      GtkTreePath  *path,
8412                                      GtkTreeIter  *iter,
8413                                      gpointer      data)
8414 {
8415   GtkTreeView *tree_view = (GtkTreeView *)data;
8416   GtkTreeIter real_iter;
8417   gboolean has_child;
8418   GtkRBTree *tree;
8419   GtkRBNode *node;
8420   gboolean free_path = FALSE;
8421
8422   g_return_if_fail (path != NULL || iter != NULL);
8423
8424   if (iter)
8425     real_iter = *iter;
8426
8427   if (path == NULL)
8428     {
8429       path = gtk_tree_model_get_path (model, iter);
8430       free_path = TRUE;
8431     }
8432   else if (iter == NULL)
8433     gtk_tree_model_get_iter (model, &real_iter, path);
8434
8435   if (_gtk_tree_view_find_node (tree_view,
8436                                 path,
8437                                 &tree,
8438                                 &node))
8439     /* We aren't actually showing the node */
8440     goto done;
8441
8442   if (tree == NULL)
8443     goto done;
8444
8445   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8446   /* Sanity check.
8447    */
8448   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8449     goto done;
8450
8451   if (has_child)
8452     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8453   else
8454     GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8455
8456   if (has_child && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
8457     {
8458       GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
8459       if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS))
8460         {
8461           GList *list;
8462
8463           for (list = tree_view->priv->columns; list; list = list->next)
8464             if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
8465               {
8466                 GTK_TREE_VIEW_COLUMN (list->data)->dirty = TRUE;
8467                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8468                 break;
8469               }
8470         }
8471       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8472     }
8473   else
8474     {
8475       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8476     }
8477
8478  done:
8479   if (free_path)
8480     gtk_tree_path_free (path);
8481 }
8482
8483 static void
8484 count_children_helper (GtkRBTree *tree,
8485                        GtkRBNode *node,
8486                        gpointer   data)
8487 {
8488   if (node->children)
8489     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8490   (*((gint *)data))++;
8491 }
8492
8493 static void
8494 check_selection_helper (GtkRBTree *tree,
8495                         GtkRBNode *node,
8496                         gpointer   data)
8497 {
8498   gint *value = (gint *)data;
8499
8500   *value = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8501
8502   if (node->children && !*value)
8503     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8504 }
8505
8506 static void
8507 gtk_tree_view_row_deleted (GtkTreeModel *model,
8508                            GtkTreePath  *path,
8509                            gpointer      data)
8510 {
8511   GtkTreeView *tree_view = (GtkTreeView *)data;
8512   GtkRBTree *tree;
8513   GtkRBNode *node;
8514   GList *list;
8515   gint selection_changed = FALSE;
8516
8517   g_return_if_fail (path != NULL);
8518
8519   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
8520
8521   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
8522     return;
8523
8524   if (tree == NULL)
8525     return;
8526
8527   /* check if the selection has been changed */
8528   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
8529                         check_selection_helper, &selection_changed);
8530
8531   for (list = tree_view->priv->columns; list; list = list->next)
8532     if (((GtkTreeViewColumn *)list->data)->visible &&
8533         ((GtkTreeViewColumn *)list->data)->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8534       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
8535
8536   /* Ensure we don't have a dangling pointer to a dead node */
8537   ensure_unprelighted (tree_view);
8538
8539   /* Cancel editting if we've started */
8540   gtk_tree_view_stop_editing (tree_view, TRUE);
8541
8542   /* If we have a node expanded/collapsed timeout, remove it */
8543   remove_expand_collapse_timeout (tree_view);
8544
8545   if (tree_view->priv->destroy_count_func)
8546     {
8547       gint child_count = 0;
8548       if (node->children)
8549         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
8550       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
8551     }
8552
8553   if (tree->root->count == 1)
8554     {
8555       if (tree_view->priv->tree == tree)
8556         tree_view->priv->tree = NULL;
8557
8558       _gtk_rbtree_remove (tree);
8559     }
8560   else
8561     {
8562       _gtk_rbtree_remove_node (tree, node);
8563     }
8564
8565   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
8566     {
8567       gtk_tree_row_reference_free (tree_view->priv->top_row);
8568       tree_view->priv->top_row = NULL;
8569     }
8570
8571   install_scroll_sync_handler (tree_view);
8572
8573   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8574
8575   if (selection_changed)
8576     g_signal_emit_by_name (tree_view->priv->selection, "changed");
8577 }
8578
8579 static void
8580 gtk_tree_view_rows_reordered (GtkTreeModel *model,
8581                               GtkTreePath  *parent,
8582                               GtkTreeIter  *iter,
8583                               gint         *new_order,
8584                               gpointer      data)
8585 {
8586   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
8587   GtkRBTree *tree;
8588   GtkRBNode *node;
8589   gint len;
8590
8591   len = gtk_tree_model_iter_n_children (model, iter);
8592
8593   if (len < 2)
8594     return;
8595
8596   gtk_tree_row_reference_reordered (G_OBJECT (data),
8597                                     parent,
8598                                     iter,
8599                                     new_order);
8600
8601   if (_gtk_tree_view_find_node (tree_view,
8602                                 parent,
8603                                 &tree,
8604                                 &node))
8605     return;
8606
8607   /* We need to special case the parent path */
8608   if (tree == NULL)
8609     tree = tree_view->priv->tree;
8610   else
8611     tree = node->children;
8612
8613   if (tree == NULL)
8614     return;
8615
8616   if (tree_view->priv->edited_column)
8617     gtk_tree_view_stop_editing (tree_view, TRUE);
8618
8619   /* we need to be unprelighted */
8620   ensure_unprelighted (tree_view);
8621
8622   /* clear the timeout */
8623   cancel_arrow_animation (tree_view);
8624
8625   _gtk_rbtree_reorder (tree, new_order, len);
8626
8627   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
8628
8629   gtk_tree_view_dy_to_top_row (tree_view);
8630 }
8631
8632
8633 /* Internal tree functions
8634  */
8635
8636
8637 static void
8638 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
8639                                      GtkRBTree         *tree,
8640                                      GtkTreeViewColumn *column,
8641                                      gint              *x1,
8642                                      gint              *x2)
8643 {
8644   GtkTreeViewColumn *tmp_column = NULL;
8645   gint total_width;
8646   GList *list;
8647   gboolean rtl;
8648
8649   if (x1)
8650     *x1 = 0;
8651
8652   if (x2)
8653     *x2 = 0;
8654
8655   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8656
8657   total_width = 0;
8658   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
8659        list;
8660        list = (rtl ? list->prev : list->next))
8661     {
8662       tmp_column = list->data;
8663
8664       if (tmp_column == column)
8665         break;
8666
8667       if (tmp_column->visible)
8668         total_width += tmp_column->width;
8669     }
8670
8671   if (tmp_column != column)
8672     {
8673       g_warning (G_STRLOC": passed-in column isn't in the tree");
8674       return;
8675     }
8676
8677   if (x1)
8678     *x1 = total_width;
8679
8680   if (x2)
8681     {
8682       if (column->visible)
8683         *x2 = total_width + column->width;
8684       else
8685         *x2 = total_width; /* width of 0 */
8686     }
8687 }
8688 static void
8689 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
8690                                 GtkRBTree   *tree,
8691                                 gint        *x1,
8692                                 gint        *x2)
8693 {
8694   gint x_offset = 0;
8695   GList *list;
8696   GtkTreeViewColumn *tmp_column = NULL;
8697   gint total_width;
8698   gboolean indent_expanders;
8699   gboolean rtl;
8700
8701   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8702
8703   total_width = 0;
8704   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
8705        list;
8706        list = (rtl ? list->prev : list->next))
8707     {
8708       tmp_column = list->data;
8709
8710       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
8711         {
8712           if (rtl)
8713             x_offset = total_width + tmp_column->width - tree_view->priv->expander_size;
8714           else
8715             x_offset = total_width;
8716           break;
8717         }
8718
8719       if (tmp_column->visible)
8720         total_width += tmp_column->width;
8721     }
8722
8723   gtk_widget_style_get (GTK_WIDGET (tree_view),
8724                         "indent-expanders", &indent_expanders,
8725                         NULL);
8726
8727   if (indent_expanders)
8728     {
8729       if (rtl)
8730         x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
8731       else
8732         x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
8733     }
8734
8735   *x1 = x_offset;
8736
8737   if (tmp_column && tmp_column->visible)
8738     /* +1 because x2 isn't included in the range. */
8739     *x2 = *x1 + tree_view->priv->expander_size + 1;
8740   else
8741     *x2 = *x1;
8742 }
8743
8744 static void
8745 gtk_tree_view_build_tree (GtkTreeView *tree_view,
8746                           GtkRBTree   *tree,
8747                           GtkTreeIter *iter,
8748                           gint         depth,
8749                           gboolean     recurse)
8750 {
8751   GtkRBNode *temp = NULL;
8752   GtkTreePath *path = NULL;
8753   gboolean is_list = GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST);
8754
8755   do
8756     {
8757       gtk_tree_model_ref_node (tree_view->priv->model, iter);
8758       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
8759
8760       if (tree_view->priv->fixed_height > 0)
8761         {
8762           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
8763             {
8764               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
8765               _gtk_rbtree_node_mark_valid (tree, temp);
8766             }
8767         }
8768
8769       if (is_list)
8770         continue;
8771
8772       if (recurse)
8773         {
8774           GtkTreeIter child;
8775
8776           if (!path)
8777             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
8778           else
8779             gtk_tree_path_next (path);
8780
8781           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
8782             {
8783               gboolean expand;
8784
8785               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
8786
8787               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
8788                   && !expand)
8789                 {
8790                   temp->children = _gtk_rbtree_new ();
8791                   temp->children->parent_tree = tree;
8792                   temp->children->parent_node = temp;
8793                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
8794                 }
8795             }
8796         }
8797
8798       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
8799         {
8800           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
8801             temp->flags ^= GTK_RBNODE_IS_PARENT;
8802         }
8803     }
8804   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
8805
8806   if (path)
8807     gtk_tree_path_free (path);
8808 }
8809
8810 /* Make sure the node is visible vertically */
8811 static void
8812 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
8813                                   GtkRBTree   *tree,
8814                                   GtkRBNode   *node)
8815 {
8816   gint node_dy, height;
8817   GtkTreePath *path = NULL;
8818
8819   if (!GTK_WIDGET_REALIZED (tree_view))
8820     return;
8821
8822   /* just return if the node is visible, avoiding a costly expose */
8823   node_dy = _gtk_rbtree_node_find_offset (tree, node);
8824   height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
8825   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
8826       && node_dy >= tree_view->priv->vadjustment->value
8827       && node_dy + height <= (tree_view->priv->vadjustment->value
8828                               + tree_view->priv->vadjustment->page_size))
8829     return;
8830
8831   path = _gtk_tree_view_find_path (tree_view, tree, node);
8832   if (path)
8833     {
8834       /* We process updates because we want to clear old selected items when we scroll.
8835        * if this is removed, we get a "selection streak" at the bottom. */
8836       gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
8837       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
8838       gtk_tree_path_free (path);
8839     }
8840 }
8841
8842 static void
8843 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
8844                                     GtkTreeViewColumn *column,
8845                                     gboolean           focus_to_cell)
8846 {
8847   gint x, width;
8848
8849   if (column == NULL)
8850     return;
8851
8852   x = column->button->allocation.x;
8853   width = column->button->allocation.width;
8854
8855   if (width > tree_view->priv->hadjustment->page_size)
8856     {
8857       /* The column is larger than the horizontal page size.  If the
8858        * column has cells which can be focussed individually, then we make
8859        * sure the cell which gets focus is fully visible (if even the
8860        * focus cell is bigger than the page size, we make sure the
8861        * left-hand side of the cell is visible).
8862        *
8863        * If the column does not have those so-called special cells, we
8864        * make sure the left-hand side of the column is visible.
8865        */
8866
8867       if (focus_to_cell && gtk_tree_view_has_special_cell (tree_view))
8868         {
8869           GtkTreePath *cursor_path;
8870           GdkRectangle background_area, cell_area, focus_area;
8871
8872           cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8873
8874           gtk_tree_view_get_cell_area (tree_view,
8875                                        cursor_path, column, &cell_area);
8876           gtk_tree_view_get_background_area (tree_view,
8877                                              cursor_path, column,
8878                                              &background_area);
8879
8880           gtk_tree_path_free (cursor_path);
8881
8882           _gtk_tree_view_column_get_focus_area (column,
8883                                                 &background_area,
8884                                                 &cell_area,
8885                                                 &focus_area);
8886
8887           x = focus_area.x;
8888           width = focus_area.width;
8889
8890           if (width < tree_view->priv->hadjustment->page_size)
8891             {
8892               if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) < (x + width))
8893                 gtk_adjustment_set_value (tree_view->priv->hadjustment,
8894                                           x + width - tree_view->priv->hadjustment->page_size);
8895               else if (tree_view->priv->hadjustment->value > x)
8896                 gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
8897             }
8898         }
8899
8900       gtk_adjustment_set_value (tree_view->priv->hadjustment,
8901                                 CLAMP (x,
8902                                        tree_view->priv->hadjustment->lower,
8903                                        tree_view->priv->hadjustment->upper
8904                                        - tree_view->priv->hadjustment->page_size));
8905     }
8906   else
8907     {
8908       if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) < (x + width))
8909           gtk_adjustment_set_value (tree_view->priv->hadjustment,
8910                                     x + width - tree_view->priv->hadjustment->page_size);
8911       else if (tree_view->priv->hadjustment->value > x)
8912         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
8913   }
8914 }
8915
8916 /* This function could be more efficient.  I'll optimize it if profiling seems
8917  * to imply that it is important */
8918 GtkTreePath *
8919 _gtk_tree_view_find_path (GtkTreeView *tree_view,
8920                           GtkRBTree   *tree,
8921                           GtkRBNode   *node)
8922 {
8923   GtkTreePath *path;
8924   GtkRBTree *tmp_tree;
8925   GtkRBNode *tmp_node, *last;
8926   gint count;
8927
8928   path = gtk_tree_path_new ();
8929
8930   g_return_val_if_fail (node != NULL, path);
8931   g_return_val_if_fail (node != tree->nil, path);
8932
8933   count = 1 + node->left->count;
8934
8935   last = node;
8936   tmp_node = node->parent;
8937   tmp_tree = tree;
8938   while (tmp_tree)
8939     {
8940       while (tmp_node != tmp_tree->nil)
8941         {
8942           if (tmp_node->right == last)
8943             count += 1 + tmp_node->left->count;
8944           last = tmp_node;
8945           tmp_node = tmp_node->parent;
8946         }
8947       gtk_tree_path_prepend_index (path, count - 1);
8948       last = tmp_tree->parent_node;
8949       tmp_tree = tmp_tree->parent_tree;
8950       if (last)
8951         {
8952           count = 1 + last->left->count;
8953           tmp_node = last->parent;
8954         }
8955     }
8956   return path;
8957 }
8958
8959 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
8960  * invalid (ie. points to a node that's not in the tree), *tree and *node are
8961  * both set to NULL.
8962  */
8963 gboolean
8964 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
8965                           GtkTreePath  *path,
8966                           GtkRBTree   **tree,
8967                           GtkRBNode   **node)
8968 {
8969   GtkRBNode *tmpnode = NULL;
8970   GtkRBTree *tmptree = tree_view->priv->tree;
8971   gint *indices = gtk_tree_path_get_indices (path);
8972   gint depth = gtk_tree_path_get_depth (path);
8973   gint i = 0;
8974
8975   *node = NULL;
8976   *tree = NULL;
8977
8978   if (depth == 0 || tmptree == NULL)
8979     return FALSE;
8980   do
8981     {
8982       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
8983       ++i;
8984       if (tmpnode == NULL)
8985         {
8986           *tree = NULL;
8987           *node = NULL;
8988           return FALSE;
8989         }
8990       if (i >= depth)
8991         {
8992           *tree = tmptree;
8993           *node = tmpnode;
8994           return FALSE;
8995         }
8996       *tree = tmptree;
8997       *node = tmpnode;
8998       tmptree = tmpnode->children;
8999       if (tmptree == NULL)
9000         return TRUE;
9001     }
9002   while (1);
9003 }
9004
9005 static gboolean
9006 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9007                                   GtkTreeViewColumn *column)
9008 {
9009   GList *list;
9010
9011   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
9012     return FALSE;
9013
9014   if (tree_view->priv->expander_column != NULL)
9015     {
9016       if (tree_view->priv->expander_column == column)
9017         return TRUE;
9018       return FALSE;
9019     }
9020   else
9021     {
9022       for (list = tree_view->priv->columns;
9023            list;
9024            list = list->next)
9025         if (((GtkTreeViewColumn *)list->data)->visible)
9026           break;
9027       if (list && list->data == column)
9028         return TRUE;
9029     }
9030   return FALSE;
9031 }
9032
9033 static void
9034 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9035                                 guint           keyval,
9036                                 guint           modmask,
9037                                 gboolean        add_shifted_binding,
9038                                 GtkMovementStep step,
9039                                 gint            count)
9040 {
9041
9042   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9043                                 "move-cursor", 2,
9044                                 G_TYPE_ENUM, step,
9045                                 G_TYPE_INT, count);
9046
9047   if (add_shifted_binding)
9048     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9049                                   "move-cursor", 2,
9050                                   G_TYPE_ENUM, step,
9051                                   G_TYPE_INT, count);
9052
9053   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9054    return;
9055
9056   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9057                                 "move-cursor", 2,
9058                                 G_TYPE_ENUM, step,
9059                                 G_TYPE_INT, count);
9060
9061   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9062                                 "move-cursor", 2,
9063                                 G_TYPE_ENUM, step,
9064                                 G_TYPE_INT, count);
9065 }
9066
9067 static gint
9068 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9069                                  GtkTreeIter  *iter,
9070                                  GtkRBTree    *tree,
9071                                  GtkRBNode    *node)
9072 {
9073   gint retval = FALSE;
9074   do
9075     {
9076       g_return_val_if_fail (node != NULL, FALSE);
9077
9078       if (node->children)
9079         {
9080           GtkTreeIter child;
9081           GtkRBTree *new_tree;
9082           GtkRBNode *new_node;
9083
9084           new_tree = node->children;
9085           new_node = new_tree->root;
9086
9087           while (new_node && new_node->left != new_tree->nil)
9088             new_node = new_node->left;
9089
9090           if (!gtk_tree_model_iter_children (model, &child, iter))
9091             return FALSE;
9092
9093           retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
9094         }
9095
9096       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9097         retval = TRUE;
9098       gtk_tree_model_unref_node (model, iter);
9099       node = _gtk_rbtree_next (tree, node);
9100     }
9101   while (gtk_tree_model_iter_next (model, iter));
9102
9103   return retval;
9104 }
9105
9106 static gint
9107 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9108                                               GtkRBTree   *tree)
9109 {
9110   GtkTreeIter iter;
9111   GtkTreePath *path;
9112   GtkRBNode *node;
9113   gint retval;
9114
9115   if (!tree)
9116     return FALSE;
9117
9118   node = tree->root;
9119   while (node && node->left != tree->nil)
9120     node = node->left;
9121
9122   g_return_val_if_fail (node != NULL, FALSE);
9123   path = _gtk_tree_view_find_path (tree_view, tree, node);
9124   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9125                            &iter, path);
9126   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9127   gtk_tree_path_free (path);
9128
9129   return retval;
9130 }
9131
9132 static void
9133 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9134                                     GtkTreeViewColumn *column)
9135 {
9136   GtkTreeViewColumn *left_column;
9137   GtkTreeViewColumn *cur_column = NULL;
9138   GtkTreeViewColumnReorder *reorder;
9139   gboolean rtl;
9140   GList *tmp_list;
9141   gint left;
9142
9143   /* We want to precalculate the motion list such that we know what column slots
9144    * are available.
9145    */
9146   left_column = NULL;
9147   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9148
9149   /* First, identify all possible drop spots */
9150   if (rtl)
9151     tmp_list = g_list_last (tree_view->priv->columns);
9152   else
9153     tmp_list = g_list_first (tree_view->priv->columns);
9154
9155   while (tmp_list)
9156     {
9157       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9158       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9159
9160       if (cur_column->visible == FALSE)
9161         continue;
9162
9163       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9164       if (left_column != column && cur_column != column &&
9165           tree_view->priv->column_drop_func &&
9166           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9167         {
9168           left_column = cur_column;
9169           continue;
9170         }
9171       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9172       reorder->left_column = left_column;
9173       left_column = reorder->right_column = cur_column;
9174
9175       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9176     }
9177
9178   /* Add the last one */
9179   if (tree_view->priv->column_drop_func == NULL ||
9180       ((left_column != column) &&
9181        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9182     {
9183       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9184       reorder->left_column = left_column;
9185       reorder->right_column = NULL;
9186       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9187     }
9188
9189   /* We quickly check to see if it even makes sense to reorder columns. */
9190   /* If there is nothing that can be moved, then we return */
9191
9192   if (tree_view->priv->column_drag_info == NULL)
9193     return;
9194
9195   /* We know there are always 2 slots possbile, as you can always return column. */
9196   /* If that's all there is, return */
9197   if (tree_view->priv->column_drag_info->next == NULL ||
9198       (tree_view->priv->column_drag_info->next->next == NULL &&
9199        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9200        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9201     {
9202       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9203         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9204       g_list_free (tree_view->priv->column_drag_info);
9205       tree_view->priv->column_drag_info = NULL;
9206       return;
9207     }
9208   /* We fill in the ranges for the columns, now that we've isolated them */
9209   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9210
9211   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9212     {
9213       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9214
9215       reorder->left_align = left;
9216       if (tmp_list->next != NULL)
9217         {
9218           g_assert (tmp_list->next->data);
9219           left = reorder->right_align = (reorder->right_column->button->allocation.x +
9220                                          reorder->right_column->button->allocation.width +
9221                                          ((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column->button->allocation.x)/2;
9222         }
9223       else
9224         {
9225           gint width;
9226
9227           gdk_drawable_get_size (tree_view->priv->header_window, &width, NULL);
9228           reorder->right_align = width + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9229         }
9230     }
9231 }
9232
9233 void
9234 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9235                                   GtkTreeViewColumn *column)
9236 {
9237   GdkEvent *send_event;
9238   GtkAllocation allocation;
9239   gint x, y, width, height;
9240   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9241   GdkDisplay *display = gdk_screen_get_display (screen);
9242
9243   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9244   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9245
9246   gtk_tree_view_set_column_drag_info (tree_view, column);
9247
9248   if (tree_view->priv->column_drag_info == NULL)
9249     return;
9250
9251   if (tree_view->priv->drag_window == NULL)
9252     {
9253       GdkWindowAttr attributes;
9254       guint attributes_mask;
9255
9256       attributes.window_type = GDK_WINDOW_CHILD;
9257       attributes.wclass = GDK_INPUT_OUTPUT;
9258       attributes.x = column->button->allocation.x;
9259       attributes.y = 0;
9260       attributes.width = column->button->allocation.width;
9261       attributes.height = column->button->allocation.height;
9262       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9263       attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
9264       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9265       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
9266
9267       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
9268                                                      &attributes,
9269                                                      attributes_mask);
9270       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
9271     }
9272
9273   gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
9274   gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
9275
9276   gtk_grab_remove (column->button);
9277
9278   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9279   send_event->crossing.send_event = TRUE;
9280   send_event->crossing.window = g_object_ref (GTK_BUTTON (column->button)->event_window);
9281   send_event->crossing.subwindow = NULL;
9282   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9283   send_event->crossing.time = GDK_CURRENT_TIME;
9284
9285   gtk_propagate_event (column->button, send_event);
9286   gdk_event_free (send_event);
9287
9288   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9289   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9290   send_event->button.send_event = TRUE;
9291   send_event->button.time = GDK_CURRENT_TIME;
9292   send_event->button.x = -1;
9293   send_event->button.y = -1;
9294   send_event->button.axes = NULL;
9295   send_event->button.state = 0;
9296   send_event->button.button = 1;
9297   send_event->button.device = gdk_display_get_core_pointer (display);
9298   send_event->button.x_root = 0;
9299   send_event->button.y_root = 0;
9300
9301   gtk_propagate_event (column->button, send_event);
9302   gdk_event_free (send_event);
9303
9304   /* Kids, don't try this at home */
9305   g_object_ref (column->button);
9306   gtk_container_remove (GTK_CONTAINER (tree_view), column->button);
9307   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
9308   gtk_widget_set_parent (column->button, GTK_WIDGET (tree_view));
9309   g_object_unref (column->button);
9310
9311   tree_view->priv->drag_column_x = column->button->allocation.x;
9312   allocation = column->button->allocation;
9313   allocation.x = 0;
9314   gtk_widget_size_allocate (column->button, &allocation);
9315   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
9316
9317   tree_view->priv->drag_column = column;
9318   gdk_window_show (tree_view->priv->drag_window);
9319
9320   gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
9321   gdk_drawable_get_size (tree_view->priv->header_window, &width, &height);
9322
9323   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9324   while (gtk_events_pending ())
9325     gtk_main_iteration ();
9326
9327   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG);
9328   gdk_pointer_grab (tree_view->priv->drag_window,
9329                     FALSE,
9330                     GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9331                     NULL, NULL, GDK_CURRENT_TIME);
9332   gdk_keyboard_grab (tree_view->priv->drag_window,
9333                      FALSE,
9334                      GDK_CURRENT_TIME);
9335 }
9336
9337 static void
9338 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9339                                 GtkRBTree          *tree,
9340                                 GtkRBNode          *node,
9341                                 const GdkRectangle *clip_rect)
9342 {
9343   GdkRectangle rect;
9344
9345   if (!GTK_WIDGET_REALIZED (tree_view))
9346     return;
9347
9348   rect.x = 0;
9349   rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width));
9350
9351   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
9352   rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
9353
9354   if (clip_rect)
9355     {
9356       GdkRectangle new_rect;
9357
9358       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9359
9360       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9361     }
9362   else
9363     {
9364       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9365     }
9366 }
9367
9368 void
9369 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9370                                 GtkRBTree          *tree,
9371                                 GtkRBNode          *node,
9372                                 const GdkRectangle *clip_rect)
9373 {
9374   GdkRectangle rect;
9375
9376   if (!GTK_WIDGET_REALIZED (tree_view))
9377     return;
9378
9379   rect.x = 0;
9380   rect.width = MAX (tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width);
9381
9382   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
9383   rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
9384
9385   if (clip_rect)
9386     {
9387       GdkRectangle new_rect;
9388
9389       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9390
9391       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9392     }
9393   else
9394     {
9395       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9396     }
9397 }
9398
9399 static void
9400 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
9401                                GtkTreePath        *path,
9402                                const GdkRectangle *clip_rect)
9403 {
9404   GtkRBTree *tree = NULL;
9405   GtkRBNode *node = NULL;
9406
9407   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
9408
9409   if (tree)
9410     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
9411 }
9412
9413 /* x and y are the mouse position
9414  */
9415 static void
9416 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
9417                           GtkRBTree   *tree,
9418                           GtkRBNode   *node,
9419                           /* in bin_window coordinates */
9420                           gint         x,
9421                           gint         y)
9422 {
9423   GdkRectangle area;
9424   GtkStateType state;
9425   GtkWidget *widget;
9426   gint x_offset = 0;
9427   gint x2;
9428   gint vertical_separator;
9429   gint expander_size;
9430   GtkExpanderStyle expander_style;
9431
9432   gtk_widget_style_get (GTK_WIDGET (tree_view),
9433                         "vertical-separator", &vertical_separator,
9434                         NULL);
9435   expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
9436
9437   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
9438     return;
9439
9440   widget = GTK_WIDGET (tree_view);
9441
9442   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
9443
9444   area.x = x_offset;
9445   area.y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
9446   area.width = expander_size + 2;
9447   area.height = MAX (CELL_HEIGHT (node, vertical_separator), (expander_size - vertical_separator));
9448
9449   if (GTK_WIDGET_STATE (tree_view) == GTK_STATE_INSENSITIVE)
9450     {
9451       state = GTK_STATE_INSENSITIVE;
9452     }
9453   else if (node == tree_view->priv->button_pressed_node)
9454     {
9455       if (x >= area.x && x <= (area.x + area.width) &&
9456           y >= area.y && y <= (area.y + area.height))
9457         state = GTK_STATE_ACTIVE;
9458       else
9459         state = GTK_STATE_NORMAL;
9460     }
9461   else
9462     {
9463       if (node == tree_view->priv->prelight_node &&
9464           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
9465         state = GTK_STATE_PRELIGHT;
9466       else
9467         state = GTK_STATE_NORMAL;
9468     }
9469
9470   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
9471     expander_style = GTK_EXPANDER_SEMI_EXPANDED;
9472   else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
9473     expander_style = GTK_EXPANDER_SEMI_COLLAPSED;
9474   else if (node->children != NULL)
9475     expander_style = GTK_EXPANDER_EXPANDED;
9476   else
9477     expander_style = GTK_EXPANDER_COLLAPSED;
9478
9479   gtk_paint_expander (widget->style,
9480                       tree_view->priv->bin_window,
9481                       state,
9482                       &area,
9483                       widget,
9484                       "treeview",
9485                       area.x + area.width / 2,
9486                       area.y + area.height / 2,
9487                       expander_style);
9488 }
9489
9490 static void
9491 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
9492
9493 {
9494   GtkTreePath *cursor_path;
9495
9496   if ((tree_view->priv->tree == NULL) ||
9497       (! GTK_WIDGET_REALIZED (tree_view)))
9498     return;
9499
9500   cursor_path = NULL;
9501   if (tree_view->priv->cursor)
9502     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9503
9504   if (cursor_path == NULL)
9505     {
9506       /* Consult the selection before defaulting to the
9507        * first focusable element
9508        */
9509       GList *selected_rows;
9510       GtkTreeModel *model;
9511       GtkTreeSelection *selection;
9512
9513       selection = gtk_tree_view_get_selection (tree_view);
9514       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
9515
9516       if (selected_rows)
9517         {
9518           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
9519           g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
9520           g_list_free (selected_rows);
9521         }
9522       else
9523         {
9524           cursor_path = gtk_tree_path_new_first ();
9525           search_first_focusable_path (tree_view, &cursor_path,
9526                                        TRUE, NULL, NULL);
9527         }
9528
9529       gtk_tree_row_reference_free (tree_view->priv->cursor);
9530       tree_view->priv->cursor = NULL;
9531
9532       if (cursor_path)
9533         {
9534           if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE)
9535             gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE);
9536           else
9537             gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
9538         }
9539     }
9540
9541   if (cursor_path)
9542     {
9543       GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
9544
9545       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
9546       gtk_tree_path_free (cursor_path);
9547
9548       if (tree_view->priv->focus_column == NULL)
9549         {
9550           GList *list;
9551           for (list = tree_view->priv->columns; list; list = list->next)
9552             {
9553               if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
9554                 {
9555                   tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
9556                   break;
9557                 }
9558             }
9559         }
9560     }
9561 }
9562
9563 static void
9564 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
9565                                    gint         count)
9566 {
9567   gint selection_count;
9568   GtkRBTree *cursor_tree = NULL;
9569   GtkRBNode *cursor_node = NULL;
9570   GtkRBTree *new_cursor_tree = NULL;
9571   GtkRBNode *new_cursor_node = NULL;
9572   GtkTreePath *cursor_path = NULL;
9573   gboolean grab_focus = TRUE;
9574   gboolean selectable;
9575
9576   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
9577     return;
9578
9579   cursor_path = NULL;
9580   if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
9581     /* FIXME: we lost the cursor; should we get the first? */
9582     return;
9583
9584   cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9585   _gtk_tree_view_find_node (tree_view, cursor_path,
9586                             &cursor_tree, &cursor_node);
9587
9588   if (cursor_tree == NULL)
9589     /* FIXME: we lost the cursor; should we get the first? */
9590     return;
9591
9592   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
9593   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
9594                                                       cursor_node,
9595                                                       cursor_path);
9596
9597   if (selection_count == 0
9598       && tree_view->priv->selection->type != GTK_SELECTION_NONE
9599       && !tree_view->priv->ctrl_pressed
9600       && selectable)
9601     {
9602       /* Don't move the cursor, but just select the current node */
9603       new_cursor_tree = cursor_tree;
9604       new_cursor_node = cursor_node;
9605     }
9606   else
9607     {
9608       if (count == -1)
9609         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
9610                                &new_cursor_tree, &new_cursor_node);
9611       else
9612         _gtk_rbtree_next_full (cursor_tree, cursor_node,
9613                                &new_cursor_tree, &new_cursor_node);
9614     }
9615
9616   gtk_tree_path_free (cursor_path);
9617
9618   if (new_cursor_node)
9619     {
9620       cursor_path = _gtk_tree_view_find_path (tree_view,
9621                                               new_cursor_tree, new_cursor_node);
9622
9623       search_first_focusable_path (tree_view, &cursor_path,
9624                                    (count != -1),
9625                                    &new_cursor_tree,
9626                                    &new_cursor_node);
9627
9628       if (cursor_path)
9629         gtk_tree_path_free (cursor_path);
9630     }
9631
9632   /*
9633    * If the list has only one item and multi-selection is set then select
9634    * the row (if not yet selected).
9635    */
9636   if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE &&
9637       new_cursor_node == NULL)
9638     {
9639       if (count == -1)
9640         _gtk_rbtree_next_full (cursor_tree, cursor_node,
9641                                &new_cursor_tree, &new_cursor_node);
9642       else
9643         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
9644                                &new_cursor_tree, &new_cursor_node);
9645
9646       if (new_cursor_node == NULL
9647           && !GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_SELECTED))
9648         {
9649           new_cursor_node = cursor_node;
9650           new_cursor_tree = cursor_tree;
9651         }
9652       else
9653         {
9654           new_cursor_node = NULL;
9655         }
9656     }
9657
9658   if (new_cursor_node)
9659     {
9660       cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node);
9661       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
9662       gtk_tree_path_free (cursor_path);
9663     }
9664   else
9665     {
9666       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
9667
9668       if (!tree_view->priv->shift_pressed)
9669         {
9670           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
9671                                           count < 0 ?
9672                                           GTK_DIR_UP : GTK_DIR_DOWN))
9673             {
9674               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
9675
9676               if (toplevel)
9677                 gtk_widget_child_focus (toplevel,
9678                                         count < 0 ?
9679                                         GTK_DIR_TAB_BACKWARD :
9680                                         GTK_DIR_TAB_FORWARD);
9681
9682               grab_focus = FALSE;
9683             }
9684         }
9685       else
9686         {
9687           gtk_widget_error_bell (GTK_WIDGET (tree_view));
9688         }
9689     }
9690
9691   if (grab_focus)
9692     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9693 }
9694
9695 static void
9696 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
9697                                         gint         count)
9698 {
9699   GtkRBTree *cursor_tree = NULL;
9700   GtkRBNode *cursor_node = NULL;
9701   GtkTreePath *old_cursor_path = NULL;
9702   GtkTreePath *cursor_path = NULL;
9703   GtkRBTree *start_cursor_tree = NULL;
9704   GtkRBNode *start_cursor_node = NULL;
9705   gint y;
9706   gint window_y;
9707   gint vertical_separator;
9708
9709   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
9710     return;
9711
9712   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
9713     old_cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9714   else
9715     /* This is sorta weird.  Focus in should give us a cursor */
9716     return;
9717
9718   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
9719   _gtk_tree_view_find_node (tree_view, old_cursor_path,
9720                             &cursor_tree, &cursor_node);
9721
9722   if (cursor_tree == NULL)
9723     {
9724       /* FIXME: we lost the cursor.  Should we try to get one? */
9725       gtk_tree_path_free (old_cursor_path);
9726       return;
9727     }
9728   g_return_if_fail (cursor_node != NULL);
9729
9730   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
9731   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
9732   y += tree_view->priv->cursor_offset;
9733   y += count * (int)tree_view->priv->vadjustment->page_increment;
9734   y = CLAMP (y, (gint)tree_view->priv->vadjustment->lower,  (gint)tree_view->priv->vadjustment->upper - vertical_separator);
9735
9736   if (y >= tree_view->priv->height)
9737     y = tree_view->priv->height - 1;
9738
9739   tree_view->priv->cursor_offset =
9740     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
9741                              &cursor_tree, &cursor_node);
9742
9743   if (tree_view->priv->cursor_offset > BACKGROUND_HEIGHT (cursor_node))
9744     {
9745       _gtk_rbtree_next_full (cursor_tree, cursor_node,
9746                              &cursor_tree, &cursor_node);
9747       tree_view->priv->cursor_offset -= BACKGROUND_HEIGHT (cursor_node);
9748     }
9749
9750   y -= tree_view->priv->cursor_offset;
9751   cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
9752
9753   start_cursor_tree = cursor_tree;
9754   start_cursor_node = cursor_node;
9755
9756   if (! search_first_focusable_path (tree_view, &cursor_path,
9757                                      (count != -1),
9758                                      &cursor_tree, &cursor_node))
9759     {
9760       /* It looks like we reached the end of the view without finding
9761        * a focusable row.  We will step backwards to find the last
9762        * focusable row.
9763        */
9764       cursor_tree = start_cursor_tree;
9765       cursor_node = start_cursor_node;
9766       cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
9767
9768       search_first_focusable_path (tree_view, &cursor_path,
9769                                    (count == -1),
9770                                    &cursor_tree, &cursor_node);
9771     }
9772
9773   if (!cursor_path)
9774     goto cleanup;
9775
9776   /* update y */
9777   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
9778
9779   gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
9780
9781   y -= window_y;
9782   gtk_tree_view_scroll_to_point (tree_view, -1, y);
9783   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
9784   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
9785
9786   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
9787     gtk_widget_error_bell (GTK_WIDGET (tree_view));
9788
9789   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9790
9791 cleanup:
9792   gtk_tree_path_free (old_cursor_path);
9793   gtk_tree_path_free (cursor_path);
9794 }
9795
9796 static void
9797 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
9798                                       gint         count)
9799 {
9800   GtkRBTree *cursor_tree = NULL;
9801   GtkRBNode *cursor_node = NULL;
9802   GtkTreePath *cursor_path = NULL;
9803   GtkTreeViewColumn *column;
9804   GtkTreeIter iter;
9805   GList *list;
9806   gboolean found_column = FALSE;
9807   gboolean rtl;
9808
9809   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9810
9811   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
9812     return;
9813
9814   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
9815     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9816   else
9817     return;
9818
9819   _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node);
9820   if (cursor_tree == NULL)
9821     return;
9822   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
9823     {
9824       gtk_tree_path_free (cursor_path);
9825       return;
9826     }
9827   gtk_tree_path_free (cursor_path);
9828
9829   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
9830   if (tree_view->priv->focus_column)
9831     {
9832       for (; list; list = (rtl ? list->prev : list->next))
9833         {
9834           if (list->data == tree_view->priv->focus_column)
9835             break;
9836         }
9837     }
9838
9839   while (list)
9840     {
9841       gboolean left, right;
9842
9843       column = list->data;
9844       if (column->visible == FALSE)
9845         goto loop_end;
9846
9847       gtk_tree_view_column_cell_set_cell_data (column,
9848                                                tree_view->priv->model,
9849                                                &iter,
9850                                                GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
9851                                                cursor_node->children?TRUE:FALSE);
9852
9853       if (rtl)
9854         {
9855           right = list->prev ? TRUE : FALSE;
9856           left = list->next ? TRUE : FALSE;
9857         }
9858       else
9859         {
9860           left = list->prev ? TRUE : FALSE;
9861           right = list->next ? TRUE : FALSE;
9862         }
9863
9864       if (_gtk_tree_view_column_cell_focus (column, count, left, right))
9865         {
9866           tree_view->priv->focus_column = column;
9867           found_column = TRUE;
9868           break;
9869         }
9870     loop_end:
9871       if (count == 1)
9872         list = rtl ? list->prev : list->next;
9873       else
9874         list = rtl ? list->next : list->prev;
9875     }
9876
9877   if (found_column)
9878     {
9879       if (!gtk_tree_view_has_special_cell (tree_view))
9880         _gtk_tree_view_queue_draw_node (tree_view,
9881                                         cursor_tree,
9882                                         cursor_node,
9883                                         NULL);
9884       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
9885       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9886     }
9887   else
9888     {
9889       gtk_widget_error_bell (GTK_WIDGET (tree_view));
9890     }
9891
9892   gtk_tree_view_clamp_column_visible (tree_view,
9893                                       tree_view->priv->focus_column, TRUE);
9894 }
9895
9896 static void
9897 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
9898                                      gint         count)
9899 {
9900   GtkRBTree *cursor_tree;
9901   GtkRBNode *cursor_node;
9902   GtkTreePath *path;
9903   GtkTreePath *old_path;
9904
9905   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
9906     return;
9907
9908   g_return_if_fail (tree_view->priv->tree != NULL);
9909
9910   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
9911
9912   cursor_tree = tree_view->priv->tree;
9913   cursor_node = cursor_tree->root;
9914
9915   if (count == -1)
9916     {
9917       while (cursor_node && cursor_node->left != cursor_tree->nil)
9918         cursor_node = cursor_node->left;
9919
9920       /* Now go forward to find the first focusable row. */
9921       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
9922       search_first_focusable_path (tree_view, &path,
9923                                    TRUE, &cursor_tree, &cursor_node);
9924     }
9925   else
9926     {
9927       do
9928         {
9929           while (cursor_node && cursor_node->right != cursor_tree->nil)
9930             cursor_node = cursor_node->right;
9931           if (cursor_node->children == NULL)
9932             break;
9933
9934           cursor_tree = cursor_node->children;
9935           cursor_node = cursor_tree->root;
9936         }
9937       while (1);
9938
9939       /* Now go backwards to find last focusable row. */
9940       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
9941       search_first_focusable_path (tree_view, &path,
9942                                    FALSE, &cursor_tree, &cursor_node);
9943     }
9944
9945   if (!path)
9946     goto cleanup;
9947
9948   if (gtk_tree_path_compare (old_path, path))
9949     {
9950       gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
9951       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9952     }
9953   else
9954     {
9955       gtk_widget_error_bell (GTK_WIDGET (tree_view));
9956     }
9957
9958 cleanup:
9959   gtk_tree_path_free (old_path);
9960   gtk_tree_path_free (path);
9961 }
9962
9963 static gboolean
9964 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
9965 {
9966   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
9967     return FALSE;
9968
9969   if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
9970     return FALSE;
9971
9972   gtk_tree_selection_select_all (tree_view->priv->selection);
9973
9974   return TRUE;
9975 }
9976
9977 static gboolean
9978 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
9979 {
9980   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
9981     return FALSE;
9982
9983   if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
9984     return FALSE;
9985
9986   gtk_tree_selection_unselect_all (tree_view->priv->selection);
9987
9988   return TRUE;
9989 }
9990
9991 static gboolean
9992 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
9993                                       gboolean     start_editing)
9994 {
9995   GtkRBTree *new_tree = NULL;
9996   GtkRBNode *new_node = NULL;
9997   GtkRBTree *cursor_tree = NULL;
9998   GtkRBNode *cursor_node = NULL;
9999   GtkTreePath *cursor_path = NULL;
10000   GtkTreeSelectMode mode = 0;
10001
10002   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
10003     return FALSE;
10004
10005   if (tree_view->priv->cursor)
10006     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10007
10008   if (cursor_path == NULL)
10009     return FALSE;
10010
10011   _gtk_tree_view_find_node (tree_view, cursor_path,
10012                             &cursor_tree, &cursor_node);
10013
10014   if (cursor_tree == NULL)
10015     {
10016       gtk_tree_path_free (cursor_path);
10017       return FALSE;
10018     }
10019
10020   if (!tree_view->priv->shift_pressed && start_editing &&
10021       tree_view->priv->focus_column)
10022     {
10023       if (gtk_tree_view_start_editing (tree_view, cursor_path))
10024         {
10025           gtk_tree_path_free (cursor_path);
10026           return TRUE;
10027         }
10028     }
10029
10030   if (tree_view->priv->ctrl_pressed)
10031     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10032   if (tree_view->priv->shift_pressed)
10033     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10034
10035   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10036                                             cursor_node,
10037                                             cursor_tree,
10038                                             cursor_path,
10039                                             mode,
10040                                             FALSE);
10041
10042   /* We bail out if the original (tree, node) don't exist anymore after
10043    * handling the selection-changed callback.  We do return TRUE because
10044    * the key press has been handled at this point.
10045    */
10046   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10047
10048   if (cursor_tree != new_tree || cursor_node != new_node)
10049     return FALSE;
10050
10051   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10052
10053   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10054   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10055
10056   if (!tree_view->priv->shift_pressed)
10057     gtk_tree_view_row_activated (tree_view, cursor_path,
10058                                  tree_view->priv->focus_column);
10059
10060   gtk_tree_path_free (cursor_path);
10061
10062   return TRUE;
10063 }
10064
10065 static gboolean
10066 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10067 {
10068   GtkRBTree *new_tree = NULL;
10069   GtkRBNode *new_node = NULL;
10070   GtkRBTree *cursor_tree = NULL;
10071   GtkRBNode *cursor_node = NULL;
10072   GtkTreePath *cursor_path = NULL;
10073
10074   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
10075     return FALSE;
10076
10077   cursor_path = NULL;
10078   if (tree_view->priv->cursor)
10079     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10080
10081   if (cursor_path == NULL)
10082     return FALSE;
10083
10084   _gtk_tree_view_find_node (tree_view, cursor_path,
10085                             &cursor_tree, &cursor_node);
10086   if (cursor_tree == NULL)
10087     {
10088       gtk_tree_path_free (cursor_path);
10089       return FALSE;
10090     }
10091
10092   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10093                                             cursor_node,
10094                                             cursor_tree,
10095                                             cursor_path,
10096                                             GTK_TREE_SELECT_MODE_TOGGLE,
10097                                             FALSE);
10098
10099   /* We bail out if the original (tree, node) don't exist anymore after
10100    * handling the selection-changed callback.  We do return TRUE because
10101    * the key press has been handled at this point.
10102    */
10103   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10104
10105   if (cursor_tree != new_tree || cursor_node != new_node)
10106     return FALSE;
10107
10108   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10109
10110   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10111   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10112   gtk_tree_path_free (cursor_path);
10113
10114   return TRUE;
10115 }
10116
10117 static gboolean
10118 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10119                                                gboolean     logical,
10120                                                gboolean     expand,
10121                                                gboolean     open_all)
10122 {
10123   GtkTreePath *cursor_path = NULL;
10124   GtkRBTree *tree;
10125   GtkRBNode *node;
10126
10127   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
10128     return FALSE;
10129
10130   cursor_path = NULL;
10131   if (tree_view->priv->cursor)
10132     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10133
10134   if (cursor_path == NULL)
10135     return FALSE;
10136
10137   if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node))
10138     return FALSE;
10139
10140   /* Don't handle the event if we aren't an expander */
10141   if (!((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT))
10142     return FALSE;
10143
10144   if (!logical
10145       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10146     expand = !expand;
10147
10148   if (expand)
10149     gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE);
10150   else
10151     gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE);
10152
10153   gtk_tree_path_free (cursor_path);
10154
10155   return TRUE;
10156 }
10157
10158 static gboolean
10159 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10160 {
10161   GtkRBTree *cursor_tree = NULL;
10162   GtkRBNode *cursor_node = NULL;
10163   GtkTreePath *cursor_path = NULL;
10164   GdkModifierType state;
10165
10166   if (! GTK_WIDGET_HAS_FOCUS (tree_view))
10167     goto out;
10168
10169   cursor_path = NULL;
10170   if (tree_view->priv->cursor)
10171     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10172
10173   if (cursor_path == NULL)
10174     goto out;
10175
10176   _gtk_tree_view_find_node (tree_view, cursor_path,
10177                             &cursor_tree, &cursor_node);
10178   if (cursor_tree == NULL)
10179     {
10180       gtk_tree_path_free (cursor_path);
10181       goto out;
10182     }
10183
10184   if (cursor_tree->parent_node)
10185     {
10186       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10187       cursor_node = cursor_tree->parent_node;
10188       cursor_tree = cursor_tree->parent_tree;
10189
10190       gtk_tree_path_up (cursor_path);
10191
10192       if (gtk_get_current_event_state (&state))
10193         {
10194           if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
10195             tree_view->priv->ctrl_pressed = TRUE;
10196         }
10197
10198       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10199       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10200
10201       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10202       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10203       gtk_tree_path_free (cursor_path);
10204
10205       tree_view->priv->ctrl_pressed = FALSE;
10206
10207       return TRUE;
10208     }
10209
10210  out:
10211
10212   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10213   return FALSE;
10214 }
10215
10216 static gboolean
10217 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10218 {
10219   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view);
10220   tree_view->priv->typeselect_flush_timeout = 0;
10221
10222   return FALSE;
10223 }
10224
10225 /* Cut and paste from gtkwindow.c */
10226 static void
10227 send_focus_change (GtkWidget *widget,
10228                    gboolean   in)
10229 {
10230   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10231
10232   g_object_ref (widget);
10233
10234  if (in)
10235     GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
10236   else
10237     GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
10238
10239   fevent->focus_change.type = GDK_FOCUS_CHANGE;
10240   fevent->focus_change.window = g_object_ref (widget->window);
10241   fevent->focus_change.in = in;
10242
10243   gtk_widget_event (widget, fevent);
10244
10245   g_object_notify (G_OBJECT (widget), "has-focus");
10246
10247   g_object_unref (widget);
10248   gdk_event_free (fevent);
10249 }
10250
10251 static void
10252 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10253 {
10254   GtkWidget *frame, *vbox, *toplevel;
10255   GdkScreen *screen;
10256
10257   if (tree_view->priv->search_custom_entry_set)
10258     return;
10259
10260   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10261   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10262
10263    if (tree_view->priv->search_window != NULL)
10264      {
10265        if (GTK_WINDOW (toplevel)->group)
10266          gtk_window_group_add_window (GTK_WINDOW (toplevel)->group,
10267                                       GTK_WINDOW (tree_view->priv->search_window));
10268        else if (GTK_WINDOW (tree_view->priv->search_window)->group)
10269          gtk_window_group_remove_window (GTK_WINDOW (tree_view->priv->search_window)->group,
10270                                          GTK_WINDOW (tree_view->priv->search_window));
10271        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10272        return;
10273      }
10274
10275   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10276   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10277
10278   if (GTK_WINDOW (toplevel)->group)
10279     gtk_window_group_add_window (GTK_WINDOW (toplevel)->group,
10280                                  GTK_WINDOW (tree_view->priv->search_window));
10281
10282   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10283                             GDK_WINDOW_TYPE_HINT_UTILITY);
10284   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10285   g_signal_connect (tree_view->priv->search_window, "delete-event",
10286                     G_CALLBACK (gtk_tree_view_search_delete_event),
10287                     tree_view);
10288   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10289                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10290                     tree_view);
10291   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10292                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10293                     tree_view);
10294   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10295                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10296                     tree_view);
10297
10298   frame = gtk_frame_new (NULL);
10299   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10300   gtk_widget_show (frame);
10301   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10302
10303   vbox = gtk_vbox_new (FALSE, 0);
10304   gtk_widget_show (vbox);
10305   gtk_container_add (GTK_CONTAINER (frame), vbox);
10306   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
10307
10308   /* add entry */
10309   tree_view->priv->search_entry = gtk_entry_new ();
10310   gtk_widget_show (tree_view->priv->search_entry);
10311   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
10312                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
10313                     tree_view);
10314   g_signal_connect (tree_view->priv->search_entry,
10315                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
10316                     tree_view);
10317   g_signal_connect (GTK_ENTRY (tree_view->priv->search_entry)->im_context,
10318                     "preedit-changed",
10319                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
10320                     tree_view);
10321   gtk_container_add (GTK_CONTAINER (vbox),
10322                      tree_view->priv->search_entry);
10323
10324   gtk_widget_realize (tree_view->priv->search_entry);
10325 }
10326
10327 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
10328  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
10329  */
10330 static gboolean
10331 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
10332                                              gboolean     keybinding)
10333 {
10334   /* We only start interactive search if we have focus or the columns
10335    * have focus.  If one of our children have focus, we don't want to
10336    * start the search.
10337    */
10338   GList *list;
10339   gboolean found_focus = FALSE;
10340   GtkWidgetClass *entry_parent_class;
10341
10342   if (!tree_view->priv->enable_search && !keybinding)
10343     return FALSE;
10344
10345   if (tree_view->priv->search_custom_entry_set)
10346     return FALSE;
10347
10348   if (tree_view->priv->search_window != NULL &&
10349       GTK_WIDGET_VISIBLE (tree_view->priv->search_window))
10350     return TRUE;
10351
10352   for (list = tree_view->priv->columns; list; list = list->next)
10353     {
10354       GtkTreeViewColumn *column;
10355
10356       column = list->data;
10357       if (! column->visible)
10358         continue;
10359
10360       if (GTK_WIDGET_HAS_FOCUS (column->button))
10361         {
10362           found_focus = TRUE;
10363           break;
10364         }
10365     }
10366
10367   if (GTK_WIDGET_HAS_FOCUS (tree_view))
10368     found_focus = TRUE;
10369
10370   if (!found_focus)
10371     return FALSE;
10372
10373   if (tree_view->priv->search_column < 0)
10374     return FALSE;
10375
10376   gtk_tree_view_ensure_interactive_directory (tree_view);
10377
10378   if (keybinding)
10379     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
10380
10381   /* done, show it */
10382   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
10383   gtk_widget_show (tree_view->priv->search_window);
10384   if (tree_view->priv->search_entry_changed_id == 0)
10385     {
10386       tree_view->priv->search_entry_changed_id =
10387         g_signal_connect (tree_view->priv->search_entry, "changed",
10388                           G_CALLBACK (gtk_tree_view_search_init),
10389                           tree_view);
10390     }
10391
10392   tree_view->priv->typeselect_flush_timeout =
10393     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
10394                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
10395                    tree_view);
10396
10397   /* Grab focus will select all the text.  We don't want that to happen, so we
10398    * call the parent instance and bypass the selection change.  This is probably
10399    * really non-kosher. */
10400   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
10401   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
10402
10403   /* send focus-in event */
10404   send_focus_change (tree_view->priv->search_entry, TRUE);
10405
10406   /* search first matching iter */
10407   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
10408
10409   return TRUE;
10410 }
10411
10412 static gboolean
10413 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
10414 {
10415   return gtk_tree_view_real_start_interactive_search (tree_view, TRUE);
10416 }
10417
10418 /* this function returns the new width of the column being resized given
10419  * the column and x position of the cursor; the x cursor position is passed
10420  * in as a pointer and automagicly corrected if it's beyond min/max limits
10421  */
10422 static gint
10423 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
10424                                 gint       i,
10425                                 gint      *x)
10426 {
10427   GtkTreeViewColumn *column;
10428   gint width;
10429   gboolean rtl;
10430
10431   /* first translate the x position from widget->window
10432    * to clist->clist_window
10433    */
10434   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10435   column = g_list_nth (tree_view->priv->columns, i)->data;
10436   width = rtl ? (column->button->allocation.x + column->button->allocation.width - *x) : (*x - column->button->allocation.x);
10437
10438   /* Clamp down the value */
10439   if (column->min_width == -1)
10440     width = MAX (column->button->requisition.width,
10441                  width);
10442   else
10443     width = MAX (column->min_width,
10444                  width);
10445   if (column->max_width != -1)
10446     width = MIN (width, column->max_width);
10447
10448   *x = rtl ? (column->button->allocation.x + column->button->allocation.width - width) : (column->button->allocation.x + width);
10449
10450   return width;
10451 }
10452
10453
10454 /* FIXME this adjust_allocation is a big cut-and-paste from
10455  * GtkCList, needs to be some "official" way to do this
10456  * factored out.
10457  */
10458 typedef struct
10459 {
10460   GdkWindow *window;
10461   int dx;
10462   int dy;
10463 } ScrollData;
10464
10465 /* The window to which widget->window is relative */
10466 #define ALLOCATION_WINDOW(widget)               \
10467    (GTK_WIDGET_NO_WINDOW (widget) ?             \
10468     (widget)->window :                          \
10469      gdk_window_get_parent ((widget)->window))
10470
10471 static void
10472 adjust_allocation_recurse (GtkWidget *widget,
10473                            gpointer   data)
10474 {
10475   ScrollData *scroll_data = data;
10476
10477   /* Need to really size allocate instead of just poking
10478    * into widget->allocation if the widget is not realized.
10479    * FIXME someone figure out why this was.
10480    */
10481   if (!GTK_WIDGET_REALIZED (widget))
10482     {
10483       if (GTK_WIDGET_VISIBLE (widget))
10484         {
10485           GdkRectangle tmp_rectangle = widget->allocation;
10486           tmp_rectangle.x += scroll_data->dx;
10487           tmp_rectangle.y += scroll_data->dy;
10488
10489           gtk_widget_size_allocate (widget, &tmp_rectangle);
10490         }
10491     }
10492   else
10493     {
10494       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
10495         {
10496           widget->allocation.x += scroll_data->dx;
10497           widget->allocation.y += scroll_data->dy;
10498
10499           if (GTK_IS_CONTAINER (widget))
10500             gtk_container_forall (GTK_CONTAINER (widget),
10501                                   adjust_allocation_recurse,
10502                                   data);
10503         }
10504     }
10505 }
10506
10507 static void
10508 adjust_allocation (GtkWidget *widget,
10509                    int        dx,
10510                    int        dy)
10511 {
10512   ScrollData scroll_data;
10513
10514   if (GTK_WIDGET_REALIZED (widget))
10515     scroll_data.window = ALLOCATION_WINDOW (widget);
10516   else
10517     scroll_data.window = NULL;
10518
10519   scroll_data.dx = dx;
10520   scroll_data.dy = dy;
10521
10522   adjust_allocation_recurse (widget, &scroll_data);
10523 }
10524
10525 /* Callbacks */
10526 static void
10527 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
10528                                   GtkTreeView   *tree_view)
10529 {
10530   if (GTK_WIDGET_REALIZED (tree_view))
10531     {
10532       gint dy;
10533
10534       gdk_window_move (tree_view->priv->bin_window,
10535                        - tree_view->priv->hadjustment->value,
10536                        TREE_VIEW_HEADER_HEIGHT (tree_view));
10537       gdk_window_move (tree_view->priv->header_window,
10538                        - tree_view->priv->hadjustment->value,
10539                        0);
10540       dy = tree_view->priv->dy - (int) tree_view->priv->vadjustment->value;
10541       if (dy && tree_view->priv->edited_column)
10542         {
10543           if (GTK_IS_WIDGET (tree_view->priv->edited_column->editable_widget))
10544             {
10545               GList *list;
10546               GtkWidget *widget;
10547               GtkTreeViewChild *child = NULL;
10548
10549               widget = GTK_WIDGET (tree_view->priv->edited_column->editable_widget);
10550               adjust_allocation (widget, 0, dy);
10551
10552               for (list = tree_view->priv->children; list; list = list->next)
10553                 {
10554                   child = (GtkTreeViewChild *)list->data;
10555                   if (child->widget == widget)
10556                     {
10557                       child->y += dy;
10558                       break;
10559                     }
10560                 }
10561             }
10562         }
10563       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
10564
10565       if (tree_view->priv->dy != (int) tree_view->priv->vadjustment->value)
10566         {
10567           /* update our dy and top_row */
10568           tree_view->priv->dy = (int) tree_view->priv->vadjustment->value;
10569
10570           if (!tree_view->priv->in_top_row_to_dy)
10571             gtk_tree_view_dy_to_top_row (tree_view);
10572         }
10573
10574       gdk_window_process_updates (tree_view->priv->header_window, TRUE);
10575       gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
10576     }
10577 }
10578
10579 \f
10580
10581 /* Public methods
10582  */
10583
10584 /**
10585  * gtk_tree_view_new:
10586  *
10587  * Creates a new #GtkTreeView widget.
10588  *
10589  * Return value: A newly created #GtkTreeView widget.
10590  **/
10591 GtkWidget *
10592 gtk_tree_view_new (void)
10593 {
10594   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
10595 }
10596
10597 /**
10598  * gtk_tree_view_new_with_model:
10599  * @model: the model.
10600  *
10601  * Creates a new #GtkTreeView widget with the model initialized to @model.
10602  *
10603  * Return value: A newly created #GtkTreeView widget.
10604  **/
10605 GtkWidget *
10606 gtk_tree_view_new_with_model (GtkTreeModel *model)
10607 {
10608   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
10609 }
10610
10611 /* Public Accessors
10612  */
10613
10614 /**
10615  * gtk_tree_view_get_model:
10616  * @tree_view: a #GtkTreeView
10617  *
10618  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
10619  * model is unset.
10620  *
10621  * Return value: A #GtkTreeModel, or %NULL if none is currently being used.
10622  **/
10623 GtkTreeModel *
10624 gtk_tree_view_get_model (GtkTreeView *tree_view)
10625 {
10626   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10627
10628   return tree_view->priv->model;
10629 }
10630
10631 /**
10632  * gtk_tree_view_set_model:
10633  * @tree_view: A #GtkTreeNode.
10634  * @model: (allow-none): The model.
10635  *
10636  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
10637  * set, it will remove it before setting the new model.  If @model is %NULL,
10638  * then it will unset the old model.
10639  **/
10640 void
10641 gtk_tree_view_set_model (GtkTreeView  *tree_view,
10642                          GtkTreeModel *model)
10643 {
10644   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10645   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
10646
10647   if (model == tree_view->priv->model)
10648     return;
10649
10650   if (tree_view->priv->scroll_to_path)
10651     {
10652       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
10653       tree_view->priv->scroll_to_path = NULL;
10654     }
10655
10656   if (tree_view->priv->model)
10657     {
10658       GList *tmplist = tree_view->priv->columns;
10659
10660       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
10661       gtk_tree_view_stop_editing (tree_view, TRUE);
10662
10663       remove_expand_collapse_timeout (tree_view);
10664
10665       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10666                                             gtk_tree_view_row_changed,
10667                                             tree_view);
10668       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10669                                             gtk_tree_view_row_inserted,
10670                                             tree_view);
10671       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10672                                             gtk_tree_view_row_has_child_toggled,
10673                                             tree_view);
10674       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10675                                             gtk_tree_view_row_deleted,
10676                                             tree_view);
10677       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10678                                             gtk_tree_view_rows_reordered,
10679                                             tree_view);
10680
10681       for (; tmplist; tmplist = tmplist->next)
10682         _gtk_tree_view_column_unset_model (tmplist->data,
10683                                            tree_view->priv->model);
10684
10685       if (tree_view->priv->tree)
10686         gtk_tree_view_free_rbtree (tree_view);
10687
10688       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
10689       tree_view->priv->drag_dest_row = NULL;
10690       gtk_tree_row_reference_free (tree_view->priv->cursor);
10691       tree_view->priv->cursor = NULL;
10692       gtk_tree_row_reference_free (tree_view->priv->anchor);
10693       tree_view->priv->anchor = NULL;
10694       gtk_tree_row_reference_free (tree_view->priv->top_row);
10695       tree_view->priv->top_row = NULL;
10696       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
10697       tree_view->priv->scroll_to_path = NULL;
10698
10699       tree_view->priv->scroll_to_column = NULL;
10700
10701       g_object_unref (tree_view->priv->model);
10702
10703       tree_view->priv->search_column = -1;
10704       tree_view->priv->fixed_height_check = 0;
10705       tree_view->priv->fixed_height = -1;
10706       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
10707       tree_view->priv->last_button_x = -1;
10708       tree_view->priv->last_button_y = -1;
10709     }
10710
10711   tree_view->priv->model = model;
10712
10713   if (tree_view->priv->model)
10714     {
10715       gint i;
10716       GtkTreePath *path;
10717       GtkTreeIter iter;
10718       GtkTreeModelFlags flags;
10719
10720       if (tree_view->priv->search_column == -1)
10721         {
10722           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
10723             {
10724               GType type = gtk_tree_model_get_column_type (model, i);
10725
10726               if (g_value_type_transformable (type, G_TYPE_STRING))
10727                 {
10728                   tree_view->priv->search_column = i;
10729                   break;
10730                 }
10731             }
10732         }
10733
10734       g_object_ref (tree_view->priv->model);
10735       g_signal_connect (tree_view->priv->model,
10736                         "row-changed",
10737                         G_CALLBACK (gtk_tree_view_row_changed),
10738                         tree_view);
10739       g_signal_connect (tree_view->priv->model,
10740                         "row-inserted",
10741                         G_CALLBACK (gtk_tree_view_row_inserted),
10742                         tree_view);
10743       g_signal_connect (tree_view->priv->model,
10744                         "row-has-child-toggled",
10745                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
10746                         tree_view);
10747       g_signal_connect (tree_view->priv->model,
10748                         "row-deleted",
10749                         G_CALLBACK (gtk_tree_view_row_deleted),
10750                         tree_view);
10751       g_signal_connect (tree_view->priv->model,
10752                         "rows-reordered",
10753                         G_CALLBACK (gtk_tree_view_rows_reordered),
10754                         tree_view);
10755
10756       flags = gtk_tree_model_get_flags (tree_view->priv->model);
10757       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
10758         GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
10759       else
10760         GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
10761
10762       path = gtk_tree_path_new_first ();
10763       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
10764         {
10765           tree_view->priv->tree = _gtk_rbtree_new ();
10766           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
10767         }
10768       gtk_tree_path_free (path);
10769
10770       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
10771       install_presize_handler (tree_view);
10772     }
10773
10774   g_object_notify (G_OBJECT (tree_view), "model");
10775
10776   if (tree_view->priv->selection)
10777   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
10778
10779   if (GTK_WIDGET_REALIZED (tree_view))
10780     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
10781 }
10782
10783 /**
10784  * gtk_tree_view_get_selection:
10785  * @tree_view: A #GtkTreeView.
10786  *
10787  * Gets the #GtkTreeSelection associated with @tree_view.
10788  *
10789  * Return value: A #GtkTreeSelection object.
10790  **/
10791 GtkTreeSelection *
10792 gtk_tree_view_get_selection (GtkTreeView *tree_view)
10793 {
10794   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10795
10796   return tree_view->priv->selection;
10797 }
10798
10799 /**
10800  * gtk_tree_view_get_hadjustment:
10801  * @tree_view: A #GtkTreeView
10802  *
10803  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
10804  *
10805  * Return value: A #GtkAdjustment object, or %NULL if none is currently being
10806  * used.
10807  **/
10808 GtkAdjustment *
10809 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
10810 {
10811   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10812
10813   if (tree_view->priv->hadjustment == NULL)
10814     gtk_tree_view_set_hadjustment (tree_view, NULL);
10815
10816   return tree_view->priv->hadjustment;
10817 }
10818
10819 /**
10820  * gtk_tree_view_set_hadjustment:
10821  * @tree_view: A #GtkTreeView
10822  * @adjustment: The #GtkAdjustment to set, or %NULL
10823  *
10824  * Sets the #GtkAdjustment for the current horizontal aspect.
10825  **/
10826 void
10827 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
10828                                GtkAdjustment *adjustment)
10829 {
10830   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10831
10832   gtk_tree_view_set_adjustments (tree_view,
10833                                  adjustment,
10834                                  tree_view->priv->vadjustment);
10835
10836   g_object_notify (G_OBJECT (tree_view), "hadjustment");
10837 }
10838
10839 /**
10840  * gtk_tree_view_get_vadjustment:
10841  * @tree_view: A #GtkTreeView
10842  *
10843  * Gets the #GtkAdjustment currently being used for the vertical aspect.
10844  *
10845  * Return value: A #GtkAdjustment object, or %NULL if none is currently being
10846  * used.
10847  **/
10848 GtkAdjustment *
10849 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
10850 {
10851   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10852
10853   if (tree_view->priv->vadjustment == NULL)
10854     gtk_tree_view_set_vadjustment (tree_view, NULL);
10855
10856   return tree_view->priv->vadjustment;
10857 }
10858
10859 /**
10860  * gtk_tree_view_set_vadjustment:
10861  * @tree_view: A #GtkTreeView
10862  * @adjustment: The #GtkAdjustment to set, or %NULL
10863  *
10864  * Sets the #GtkAdjustment for the current vertical aspect.
10865  **/
10866 void
10867 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
10868                                GtkAdjustment *adjustment)
10869 {
10870   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10871
10872   gtk_tree_view_set_adjustments (tree_view,
10873                                  tree_view->priv->hadjustment,
10874                                  adjustment);
10875
10876   g_object_notify (G_OBJECT (tree_view), "vadjustment");
10877 }
10878
10879 /* Column and header operations */
10880
10881 /**
10882  * gtk_tree_view_get_headers_visible:
10883  * @tree_view: A #GtkTreeView.
10884  *
10885  * Returns %TRUE if the headers on the @tree_view are visible.
10886  *
10887  * Return value: Whether the headers are visible or not.
10888  **/
10889 gboolean
10890 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
10891 {
10892   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
10893
10894   return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
10895 }
10896
10897 /**
10898  * gtk_tree_view_set_headers_visible:
10899  * @tree_view: A #GtkTreeView.
10900  * @headers_visible: %TRUE if the headers are visible
10901  *
10902  * Sets the visibility state of the headers.
10903  **/
10904 void
10905 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
10906                                    gboolean     headers_visible)
10907 {
10908   gint x, y;
10909   GList *list;
10910   GtkTreeViewColumn *column;
10911
10912   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10913
10914   headers_visible = !! headers_visible;
10915
10916   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE) == headers_visible)
10917     return;
10918
10919   if (headers_visible)
10920     GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
10921   else
10922     GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
10923
10924   if (GTK_WIDGET_REALIZED (tree_view))
10925     {
10926       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
10927       if (headers_visible)
10928         {
10929           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));
10930
10931           if (GTK_WIDGET_MAPPED (tree_view))
10932             gtk_tree_view_map_buttons (tree_view);
10933         }
10934       else
10935         {
10936           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
10937
10938           for (list = tree_view->priv->columns; list; list = list->next)
10939             {
10940               column = list->data;
10941               gtk_widget_unmap (column->button);
10942             }
10943           gdk_window_hide (tree_view->priv->header_window);
10944         }
10945     }
10946
10947   tree_view->priv->vadjustment->page_size = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
10948   tree_view->priv->vadjustment->page_increment = (GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2;
10949   tree_view->priv->vadjustment->lower = 0;
10950   tree_view->priv->vadjustment->upper = tree_view->priv->height;
10951   gtk_adjustment_changed (tree_view->priv->vadjustment);
10952
10953   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
10954
10955   g_object_notify (G_OBJECT (tree_view), "headers-visible");
10956 }
10957
10958 /**
10959  * gtk_tree_view_columns_autosize:
10960  * @tree_view: A #GtkTreeView.
10961  *
10962  * Resizes all columns to their optimal width. Only works after the
10963  * treeview has been realized.
10964  **/
10965 void
10966 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
10967 {
10968   gboolean dirty = FALSE;
10969   GList *list;
10970   GtkTreeViewColumn *column;
10971
10972   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10973
10974   for (list = tree_view->priv->columns; list; list = list->next)
10975     {
10976       column = list->data;
10977       if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
10978         continue;
10979       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
10980       dirty = TRUE;
10981     }
10982
10983   if (dirty)
10984     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
10985 }
10986
10987 /**
10988  * gtk_tree_view_set_headers_clickable:
10989  * @tree_view: A #GtkTreeView.
10990  * @setting: %TRUE if the columns are clickable.
10991  *
10992  * Allow the column title buttons to be clicked.
10993  **/
10994 void
10995 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
10996                                      gboolean   setting)
10997 {
10998   GList *list;
10999
11000   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11001
11002   for (list = tree_view->priv->columns; list; list = list->next)
11003     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11004
11005   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11006 }
11007
11008
11009 /**
11010  * gtk_tree_view_get_headers_clickable:
11011  * @tree_view: A #GtkTreeView.
11012  *
11013  * Returns whether all header columns are clickable.
11014  *
11015  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11016  *
11017  * Since: 2.10
11018  **/
11019 gboolean
11020 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11021 {
11022   GList *list;
11023
11024   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11025
11026   for (list = tree_view->priv->columns; list; list = list->next)
11027     if (!GTK_TREE_VIEW_COLUMN (list->data)->clickable)
11028       return FALSE;
11029
11030   return TRUE;
11031 }
11032
11033 /**
11034  * gtk_tree_view_set_rules_hint
11035  * @tree_view: a #GtkTreeView
11036  * @setting: %TRUE if the tree requires reading across rows
11037  *
11038  * This function tells GTK+ that the user interface for your
11039  * application requires users to read across tree rows and associate
11040  * cells with one another. By default, GTK+ will then render the tree
11041  * with alternating row colors. Do <emphasis>not</emphasis> use it
11042  * just because you prefer the appearance of the ruled tree; that's a
11043  * question for the theme. Some themes will draw tree rows in
11044  * alternating colors even when rules are turned off, and users who
11045  * prefer that appearance all the time can choose those themes. You
11046  * should call this function only as a <emphasis>semantic</emphasis>
11047  * hint to the theme engine that your tree makes alternating colors
11048  * useful from a functional standpoint (since it has lots of columns,
11049  * generally).
11050  *
11051  **/
11052 void
11053 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11054                               gboolean      setting)
11055 {
11056   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11057
11058   setting = setting != FALSE;
11059
11060   if (tree_view->priv->has_rules != setting)
11061     {
11062       tree_view->priv->has_rules = setting;
11063       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11064     }
11065
11066   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11067 }
11068
11069 /**
11070  * gtk_tree_view_get_rules_hint
11071  * @tree_view: a #GtkTreeView
11072  *
11073  * Gets the setting set by gtk_tree_view_set_rules_hint().
11074  *
11075  * Return value: %TRUE if rules are useful for the user of this tree
11076  **/
11077 gboolean
11078 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11079 {
11080   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11081
11082   return tree_view->priv->has_rules;
11083 }
11084
11085 /* Public Column functions
11086  */
11087
11088 /**
11089  * gtk_tree_view_append_column:
11090  * @tree_view: A #GtkTreeView.
11091  * @column: The #GtkTreeViewColumn to add.
11092  *
11093  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11094  * mode enabled, then @column must have its "sizing" property set to be
11095  * GTK_TREE_VIEW_COLUMN_FIXED.
11096  *
11097  * Return value: The number of columns in @tree_view after appending.
11098  **/
11099 gint
11100 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11101                              GtkTreeViewColumn *column)
11102 {
11103   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11104   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11105   g_return_val_if_fail (column->tree_view == NULL, -1);
11106
11107   return gtk_tree_view_insert_column (tree_view, column, -1);
11108 }
11109
11110
11111 /**
11112  * gtk_tree_view_remove_column:
11113  * @tree_view: A #GtkTreeView.
11114  * @column: The #GtkTreeViewColumn to remove.
11115  *
11116  * Removes @column from @tree_view.
11117  *
11118  * Return value: The number of columns in @tree_view after removing.
11119  **/
11120 gint
11121 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11122                              GtkTreeViewColumn *column)
11123 {
11124   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11125   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11126   g_return_val_if_fail (column->tree_view == GTK_WIDGET (tree_view), -1);
11127
11128   if (tree_view->priv->focus_column == column)
11129     tree_view->priv->focus_column = NULL;
11130
11131   if (tree_view->priv->edited_column == column)
11132     {
11133       gtk_tree_view_stop_editing (tree_view, TRUE);
11134
11135       /* no need to, but just to be sure ... */
11136       tree_view->priv->edited_column = NULL;
11137     }
11138
11139   g_signal_handlers_disconnect_by_func (column,
11140                                         G_CALLBACK (column_sizing_notify),
11141                                         tree_view);
11142
11143   _gtk_tree_view_column_unset_tree_view (column);
11144
11145   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11146   tree_view->priv->n_columns--;
11147
11148   if (GTK_WIDGET_REALIZED (tree_view))
11149     {
11150       GList *list;
11151
11152       _gtk_tree_view_column_unrealize_button (column);
11153       for (list = tree_view->priv->columns; list; list = list->next)
11154         {
11155           GtkTreeViewColumn *tmp_column;
11156
11157           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11158           if (tmp_column->visible)
11159             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
11160         }
11161
11162       if (tree_view->priv->n_columns == 0 &&
11163           gtk_tree_view_get_headers_visible (tree_view))
11164         gdk_window_hide (tree_view->priv->header_window);
11165
11166       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11167     }
11168
11169   g_object_unref (column);
11170   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11171
11172   return tree_view->priv->n_columns;
11173 }
11174
11175 /**
11176  * gtk_tree_view_insert_column:
11177  * @tree_view: A #GtkTreeView.
11178  * @column: The #GtkTreeViewColumn to be inserted.
11179  * @position: The position to insert @column in.
11180  *
11181  * This inserts the @column into the @tree_view at @position.  If @position is
11182  * -1, then the column is inserted at the end. If @tree_view has
11183  * "fixed_height" mode enabled, then @column must have its "sizing" property
11184  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
11185  *
11186  * Return value: The number of columns in @tree_view after insertion.
11187  **/
11188 gint
11189 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
11190                              GtkTreeViewColumn *column,
11191                              gint               position)
11192 {
11193   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11194   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11195   g_return_val_if_fail (column->tree_view == NULL, -1);
11196
11197   if (tree_view->priv->fixed_height_mode)
11198     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
11199                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
11200
11201   g_object_ref_sink (column);
11202
11203   if (tree_view->priv->n_columns == 0 &&
11204       GTK_WIDGET_REALIZED (tree_view) &&
11205       gtk_tree_view_get_headers_visible (tree_view))
11206     {
11207       gdk_window_show (tree_view->priv->header_window);
11208     }
11209
11210   g_signal_connect (column, "notify::sizing",
11211                     G_CALLBACK (column_sizing_notify), tree_view);
11212
11213   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
11214                                             column, position);
11215   tree_view->priv->n_columns++;
11216
11217   _gtk_tree_view_column_set_tree_view (column, tree_view);
11218
11219   if (GTK_WIDGET_REALIZED (tree_view))
11220     {
11221       GList *list;
11222
11223       _gtk_tree_view_column_realize_button (column);
11224
11225       for (list = tree_view->priv->columns; list; list = list->next)
11226         {
11227           column = GTK_TREE_VIEW_COLUMN (list->data);
11228           if (column->visible)
11229             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11230         }
11231       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11232     }
11233
11234   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11235
11236   return tree_view->priv->n_columns;
11237 }
11238
11239 /**
11240  * gtk_tree_view_insert_column_with_attributes:
11241  * @tree_view: A #GtkTreeView
11242  * @position: The position to insert the new column in.
11243  * @title: The title to set the header to.
11244  * @cell: The #GtkCellRenderer.
11245  * @Varargs: A %NULL-terminated list of attributes.
11246  *
11247  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
11248  * @position.  If @position is -1, then the newly created column is inserted at
11249  * the end.  The column is initialized with the attributes given. If @tree_view
11250  * has "fixed_height" mode enabled, then the new column will have its sizing
11251  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
11252  *
11253  * Return value: The number of columns in @tree_view after insertion.
11254  **/
11255 gint
11256 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
11257                                              gint             position,
11258                                              const gchar     *title,
11259                                              GtkCellRenderer *cell,
11260                                              ...)
11261 {
11262   GtkTreeViewColumn *column;
11263   gchar *attribute;
11264   va_list args;
11265   gint column_id;
11266
11267   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11268
11269   column = gtk_tree_view_column_new ();
11270   if (tree_view->priv->fixed_height_mode)
11271     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
11272
11273   gtk_tree_view_column_set_title (column, title);
11274   gtk_tree_view_column_pack_start (column, cell, TRUE);
11275
11276   va_start (args, cell);
11277
11278   attribute = va_arg (args, gchar *);
11279
11280   while (attribute != NULL)
11281     {
11282       column_id = va_arg (args, gint);
11283       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
11284       attribute = va_arg (args, gchar *);
11285     }
11286
11287   va_end (args);
11288
11289   gtk_tree_view_insert_column (tree_view, column, position);
11290
11291   return tree_view->priv->n_columns;
11292 }
11293
11294 /**
11295  * gtk_tree_view_insert_column_with_data_func:
11296  * @tree_view: a #GtkTreeView
11297  * @position: Position to insert, -1 for append
11298  * @title: column title
11299  * @cell: cell renderer for column
11300  * @func: function to set attributes of cell renderer
11301  * @data: data for @func
11302  * @dnotify: destroy notifier for @data
11303  *
11304  * Convenience function that inserts a new column into the #GtkTreeView
11305  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
11306  * attributes (normally using data from the model). See also
11307  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
11308  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
11309  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
11310  *
11311  * Return value: number of columns in the tree view post-insert
11312  **/
11313 gint
11314 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
11315                                              gint                       position,
11316                                              const gchar               *title,
11317                                              GtkCellRenderer           *cell,
11318                                              GtkTreeCellDataFunc        func,
11319                                              gpointer                   data,
11320                                              GDestroyNotify             dnotify)
11321 {
11322   GtkTreeViewColumn *column;
11323
11324   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11325
11326   column = gtk_tree_view_column_new ();
11327   if (tree_view->priv->fixed_height_mode)
11328     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
11329
11330   gtk_tree_view_column_set_title (column, title);
11331   gtk_tree_view_column_pack_start (column, cell, TRUE);
11332   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
11333
11334   gtk_tree_view_insert_column (tree_view, column, position);
11335
11336   return tree_view->priv->n_columns;
11337 }
11338
11339 /**
11340  * gtk_tree_view_get_column:
11341  * @tree_view: A #GtkTreeView.
11342  * @n: The position of the column, counting from 0.
11343  *
11344  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
11345  *
11346  * Return value: The #GtkTreeViewColumn, or %NULL if the position is outside the
11347  * range of columns.
11348  **/
11349 GtkTreeViewColumn *
11350 gtk_tree_view_get_column (GtkTreeView *tree_view,
11351                           gint         n)
11352 {
11353   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11354
11355   if (n < 0 || n >= tree_view->priv->n_columns)
11356     return NULL;
11357
11358   if (tree_view->priv->columns == NULL)
11359     return NULL;
11360
11361   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
11362 }
11363
11364 /**
11365  * gtk_tree_view_get_columns:
11366  * @tree_view: A #GtkTreeView
11367  *
11368  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
11369  * The returned list must be freed with g_list_free ().
11370  *
11371  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
11372  **/
11373 GList *
11374 gtk_tree_view_get_columns (GtkTreeView *tree_view)
11375 {
11376   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11377
11378   return g_list_copy (tree_view->priv->columns);
11379 }
11380
11381 /**
11382  * gtk_tree_view_move_column_after:
11383  * @tree_view: A #GtkTreeView
11384  * @column: The #GtkTreeViewColumn to be moved.
11385  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
11386  *
11387  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
11388  * @column is placed in the first position.
11389  **/
11390 void
11391 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
11392                                  GtkTreeViewColumn *column,
11393                                  GtkTreeViewColumn *base_column)
11394 {
11395   GList *column_list_el, *base_el = NULL;
11396
11397   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11398
11399   column_list_el = g_list_find (tree_view->priv->columns, column);
11400   g_return_if_fail (column_list_el != NULL);
11401
11402   if (base_column)
11403     {
11404       base_el = g_list_find (tree_view->priv->columns, base_column);
11405       g_return_if_fail (base_el != NULL);
11406     }
11407
11408   if (column_list_el->prev == base_el)
11409     return;
11410
11411   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
11412   if (base_el == NULL)
11413     {
11414       column_list_el->prev = NULL;
11415       column_list_el->next = tree_view->priv->columns;
11416       if (column_list_el->next)
11417         column_list_el->next->prev = column_list_el;
11418       tree_view->priv->columns = column_list_el;
11419     }
11420   else
11421     {
11422       column_list_el->prev = base_el;
11423       column_list_el->next = base_el->next;
11424       if (column_list_el->next)
11425         column_list_el->next->prev = column_list_el;
11426       base_el->next = column_list_el;
11427     }
11428
11429   if (GTK_WIDGET_REALIZED (tree_view))
11430     {
11431       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11432       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
11433     }
11434
11435   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11436 }
11437
11438 /**
11439  * gtk_tree_view_set_expander_column:
11440  * @tree_view: A #GtkTreeView
11441  * @column: %NULL, or the column to draw the expander arrow at.
11442  *
11443  * Sets the column to draw the expander arrow at. It must be in @tree_view.
11444  * If @column is %NULL, then the expander arrow is always at the first
11445  * visible column.
11446  *
11447  * If you do not want expander arrow to appear in your tree, set the
11448  * expander column to a hidden column.
11449  **/
11450 void
11451 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
11452                                    GtkTreeViewColumn *column)
11453 {
11454   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11455   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
11456
11457   if (tree_view->priv->expander_column != column)
11458     {
11459       GList *list;
11460
11461       if (column)
11462         {
11463           /* Confirm that column is in tree_view */
11464           for (list = tree_view->priv->columns; list; list = list->next)
11465             if (list->data == column)
11466               break;
11467           g_return_if_fail (list != NULL);
11468         }
11469
11470       tree_view->priv->expander_column = column;
11471       g_object_notify (G_OBJECT (tree_view), "expander-column");
11472     }
11473 }
11474
11475 /**
11476  * gtk_tree_view_get_expander_column:
11477  * @tree_view: A #GtkTreeView
11478  *
11479  * Returns the column that is the current expander column.  This
11480  * column has the expander arrow drawn next to it.
11481  *
11482  * Return value: The expander column.
11483  **/
11484 GtkTreeViewColumn *
11485 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
11486 {
11487   GList *list;
11488
11489   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11490
11491   for (list = tree_view->priv->columns; list; list = list->next)
11492     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
11493       return (GtkTreeViewColumn *) list->data;
11494   return NULL;
11495 }
11496
11497
11498 /**
11499  * gtk_tree_view_set_column_drag_function:
11500  * @tree_view: A #GtkTreeView.
11501  * @func: A function to determine which columns are reorderable, or %NULL.
11502  * @user_data: User data to be passed to @func, or %NULL
11503  * @destroy: Destroy notifier for @user_data, or %NULL
11504  *
11505  * Sets a user function for determining where a column may be dropped when
11506  * dragged.  This function is called on every column pair in turn at the
11507  * beginning of a column drag to determine where a drop can take place.  The
11508  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
11509  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
11510  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
11511  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
11512  * @tree_view reverts to the default behavior of allowing all columns to be
11513  * dropped everywhere.
11514  **/
11515 void
11516 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
11517                                         GtkTreeViewColumnDropFunc  func,
11518                                         gpointer                   user_data,
11519                                         GDestroyNotify             destroy)
11520 {
11521   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11522
11523   if (tree_view->priv->column_drop_func_data_destroy)
11524     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
11525
11526   tree_view->priv->column_drop_func = func;
11527   tree_view->priv->column_drop_func_data = user_data;
11528   tree_view->priv->column_drop_func_data_destroy = destroy;
11529 }
11530
11531 /**
11532  * gtk_tree_view_scroll_to_point:
11533  * @tree_view: a #GtkTreeView
11534  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
11535  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
11536  *
11537  * Scrolls the tree view such that the top-left corner of the visible
11538  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
11539  * in tree coordinates.  The @tree_view must be realized before
11540  * this function is called.  If it isn't, you probably want to be
11541  * using gtk_tree_view_scroll_to_cell().
11542  *
11543  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
11544  **/
11545 void
11546 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
11547                                gint         tree_x,
11548                                gint         tree_y)
11549 {
11550   GtkAdjustment *hadj;
11551   GtkAdjustment *vadj;
11552
11553   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11554   g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
11555
11556   hadj = tree_view->priv->hadjustment;
11557   vadj = tree_view->priv->vadjustment;
11558
11559   if (tree_x != -1)
11560     gtk_adjustment_set_value (hadj, CLAMP (tree_x, hadj->lower, hadj->upper - hadj->page_size));
11561   if (tree_y != -1)
11562     gtk_adjustment_set_value (vadj, CLAMP (tree_y, vadj->lower, vadj->upper - vadj->page_size));
11563 }
11564
11565 /**
11566  * gtk_tree_view_scroll_to_cell:
11567  * @tree_view: A #GtkTreeView.
11568  * @path: (allow-none): The path of the row to move to, or %NULL.
11569  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
11570  * @use_align: whether to use alignment arguments, or %FALSE.
11571  * @row_align: The vertical alignment of the row specified by @path.
11572  * @col_align: The horizontal alignment of the column specified by @column.
11573  *
11574  * Moves the alignments of @tree_view to the position specified by @column and
11575  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
11576  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
11577  * or @path need to be non-%NULL.  @row_align determines where the row is
11578  * placed, and @col_align determines where @column is placed.  Both are expected
11579  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
11580  * right/bottom alignment, 0.5 means center.
11581  *
11582  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
11583  * tree does the minimum amount of work to scroll the cell onto the screen.
11584  * This means that the cell will be scrolled to the edge closest to its current
11585  * position.  If the cell is currently visible on the screen, nothing is done.
11586  *
11587  * This function only works if the model is set, and @path is a valid row on the
11588  * model.  If the model changes before the @tree_view is realized, the centered
11589  * path will be modified to reflect this change.
11590  **/
11591 void
11592 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
11593                               GtkTreePath       *path,
11594                               GtkTreeViewColumn *column,
11595                               gboolean           use_align,
11596                               gfloat             row_align,
11597                               gfloat             col_align)
11598 {
11599   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11600   g_return_if_fail (tree_view->priv->model != NULL);
11601   g_return_if_fail (tree_view->priv->tree != NULL);
11602   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
11603   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
11604   g_return_if_fail (path != NULL || column != NULL);
11605
11606 #if 0
11607   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
11608            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
11609 #endif
11610   row_align = CLAMP (row_align, 0.0, 1.0);
11611   col_align = CLAMP (col_align, 0.0, 1.0);
11612
11613
11614   /* Note: Despite the benefits that come from having one code path for the
11615    * scrolling code, we short-circuit validate_visible_area's immplementation as
11616    * it is much slower than just going to the point.
11617    */
11618   if (! GTK_WIDGET_VISIBLE (tree_view) ||
11619       ! GTK_WIDGET_REALIZED (tree_view) ||
11620       GTK_WIDGET_ALLOC_NEEDED (tree_view) ||
11621       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
11622     {
11623       if (tree_view->priv->scroll_to_path)
11624         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11625
11626       tree_view->priv->scroll_to_path = NULL;
11627       tree_view->priv->scroll_to_column = NULL;
11628
11629       if (path)
11630         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
11631       if (column)
11632         tree_view->priv->scroll_to_column = column;
11633       tree_view->priv->scroll_to_use_align = use_align;
11634       tree_view->priv->scroll_to_row_align = row_align;
11635       tree_view->priv->scroll_to_col_align = col_align;
11636
11637       install_presize_handler (tree_view);
11638     }
11639   else
11640     {
11641       GdkRectangle cell_rect;
11642       GdkRectangle vis_rect;
11643       gint dest_x, dest_y;
11644
11645       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
11646       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
11647
11648       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
11649
11650       dest_x = vis_rect.x;
11651       dest_y = vis_rect.y;
11652
11653       if (column)
11654         {
11655           if (use_align)
11656             {
11657               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
11658             }
11659           else
11660             {
11661               if (cell_rect.x < vis_rect.x)
11662                 dest_x = cell_rect.x;
11663               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
11664                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
11665             }
11666         }
11667
11668       if (path)
11669         {
11670           if (use_align)
11671             {
11672               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
11673               dest_y = MAX (dest_y, 0);
11674             }
11675           else
11676             {
11677               if (cell_rect.y < vis_rect.y)
11678                 dest_y = cell_rect.y;
11679               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
11680                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
11681             }
11682         }
11683
11684       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
11685     }
11686 }
11687
11688 /**
11689  * gtk_tree_view_row_activated:
11690  * @tree_view: A #GtkTreeView
11691  * @path: The #GtkTreePath to be activated.
11692  * @column: The #GtkTreeViewColumn to be activated.
11693  *
11694  * Activates the cell determined by @path and @column.
11695  **/
11696 void
11697 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
11698                              GtkTreePath       *path,
11699                              GtkTreeViewColumn *column)
11700 {
11701   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11702
11703   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
11704 }
11705
11706
11707 static void
11708 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
11709                                           GtkRBNode *node,
11710                                           gpointer   data)
11711 {
11712   GtkTreeView *tree_view = data;
11713
11714   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
11715       node->children)
11716     {
11717       GtkTreePath *path;
11718       GtkTreeIter iter;
11719
11720       path = _gtk_tree_view_find_path (tree_view, tree, node);
11721       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
11722
11723       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
11724
11725       gtk_tree_path_free (path);
11726     }
11727
11728   if (node->children)
11729     _gtk_rbtree_traverse (node->children,
11730                           node->children->root,
11731                           G_PRE_ORDER,
11732                           gtk_tree_view_expand_all_emission_helper,
11733                           tree_view);
11734 }
11735
11736 /**
11737  * gtk_tree_view_expand_all:
11738  * @tree_view: A #GtkTreeView.
11739  *
11740  * Recursively expands all nodes in the @tree_view.
11741  **/
11742 void
11743 gtk_tree_view_expand_all (GtkTreeView *tree_view)
11744 {
11745   GtkTreePath *path;
11746   GtkRBTree *tree;
11747   GtkRBNode *node;
11748
11749   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11750
11751   if (tree_view->priv->tree == NULL)
11752     return;
11753
11754   path = gtk_tree_path_new_first ();
11755   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
11756
11757   while (node)
11758     {
11759       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
11760       node = _gtk_rbtree_next (tree, node);
11761       gtk_tree_path_next (path);
11762   }
11763
11764   gtk_tree_path_free (path);
11765 }
11766
11767 /* Timeout to animate the expander during expands and collapses */
11768 static gboolean
11769 expand_collapse_timeout (gpointer data)
11770 {
11771   return do_expand_collapse (data);
11772 }
11773
11774 static void
11775 add_expand_collapse_timeout (GtkTreeView *tree_view,
11776                              GtkRBTree   *tree,
11777                              GtkRBNode   *node,
11778                              gboolean     expand)
11779 {
11780   if (tree_view->priv->expand_collapse_timeout != 0)
11781     return;
11782
11783   tree_view->priv->expand_collapse_timeout =
11784       gdk_threads_add_timeout (50, expand_collapse_timeout, tree_view);
11785   tree_view->priv->expanded_collapsed_tree = tree;
11786   tree_view->priv->expanded_collapsed_node = node;
11787
11788   if (expand)
11789     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11790   else
11791     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11792 }
11793
11794 static void
11795 remove_expand_collapse_timeout (GtkTreeView *tree_view)
11796 {
11797   if (tree_view->priv->expand_collapse_timeout)
11798     {
11799       g_source_remove (tree_view->priv->expand_collapse_timeout);
11800       tree_view->priv->expand_collapse_timeout = 0;
11801     }
11802
11803   if (tree_view->priv->expanded_collapsed_node != NULL)
11804     {
11805       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_EXPANDED);
11806       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11807
11808       tree_view->priv->expanded_collapsed_node = NULL;
11809     }
11810 }
11811
11812 static void
11813 cancel_arrow_animation (GtkTreeView *tree_view)
11814 {
11815   if (tree_view->priv->expand_collapse_timeout)
11816     {
11817       while (do_expand_collapse (tree_view));
11818
11819       remove_expand_collapse_timeout (tree_view);
11820     }
11821 }
11822
11823 static gboolean
11824 do_expand_collapse (GtkTreeView *tree_view)
11825 {
11826   GtkRBNode *node;
11827   GtkRBTree *tree;
11828   gboolean expanding;
11829   gboolean redraw;
11830
11831   redraw = FALSE;
11832   expanding = TRUE;
11833
11834   node = tree_view->priv->expanded_collapsed_node;
11835   tree = tree_view->priv->expanded_collapsed_tree;
11836
11837   if (node->children == NULL)
11838     expanding = FALSE;
11839
11840   if (expanding)
11841     {
11842       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
11843         {
11844           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11845           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11846
11847           redraw = TRUE;
11848
11849         }
11850       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
11851         {
11852           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11853
11854           redraw = TRUE;
11855         }
11856     }
11857   else
11858     {
11859       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
11860         {
11861           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11862           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11863
11864           redraw = TRUE;
11865         }
11866       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
11867         {
11868           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11869
11870           redraw = TRUE;
11871
11872         }
11873     }
11874
11875   if (redraw)
11876     {
11877       gtk_tree_view_queue_draw_arrow (tree_view, tree, node, NULL);
11878
11879       return TRUE;
11880     }
11881
11882   return FALSE;
11883 }
11884
11885 /**
11886  * gtk_tree_view_collapse_all:
11887  * @tree_view: A #GtkTreeView.
11888  *
11889  * Recursively collapses all visible, expanded nodes in @tree_view.
11890  **/
11891 void
11892 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
11893 {
11894   GtkRBTree *tree;
11895   GtkRBNode *node;
11896   GtkTreePath *path;
11897   gint *indices;
11898
11899   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11900
11901   if (tree_view->priv->tree == NULL)
11902     return;
11903
11904   path = gtk_tree_path_new ();
11905   gtk_tree_path_down (path);
11906   indices = gtk_tree_path_get_indices (path);
11907
11908   tree = tree_view->priv->tree;
11909   node = tree->root;
11910   while (node && node->left != tree->nil)
11911     node = node->left;
11912
11913   while (node)
11914     {
11915       if (node->children)
11916         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
11917       indices[0]++;
11918       node = _gtk_rbtree_next (tree, node);
11919     }
11920
11921   gtk_tree_path_free (path);
11922 }
11923
11924 /**
11925  * gtk_tree_view_expand_to_path:
11926  * @tree_view: A #GtkTreeView.
11927  * @path: path to a row.
11928  *
11929  * Expands the row at @path. This will also expand all parent rows of
11930  * @path as necessary.
11931  *
11932  * Since: 2.2
11933  **/
11934 void
11935 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
11936                               GtkTreePath *path)
11937 {
11938   gint i, depth;
11939   gint *indices;
11940   GtkTreePath *tmp;
11941
11942   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11943   g_return_if_fail (path != NULL);
11944
11945   depth = gtk_tree_path_get_depth (path);
11946   indices = gtk_tree_path_get_indices (path);
11947
11948   tmp = gtk_tree_path_new ();
11949   g_return_if_fail (tmp != NULL);
11950
11951   for (i = 0; i < depth; i++)
11952     {
11953       gtk_tree_path_append_index (tmp, indices[i]);
11954       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
11955     }
11956
11957   gtk_tree_path_free (tmp);
11958 }
11959
11960 /* FIXME the bool return values for expand_row and collapse_row are
11961  * not analagous; they should be TRUE if the row had children and
11962  * was not already in the requested state.
11963  */
11964
11965
11966 static gboolean
11967 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
11968                                GtkTreePath *path,
11969                                GtkRBTree   *tree,
11970                                GtkRBNode   *node,
11971                                gboolean     open_all,
11972                                gboolean     animate)
11973 {
11974   GtkTreeIter iter;
11975   GtkTreeIter temp;
11976   gboolean expand;
11977
11978   if (animate)
11979     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
11980                   "gtk-enable-animations", &animate,
11981                   NULL);
11982
11983   remove_auto_expand_timeout (tree_view);
11984
11985   if (node->children && !open_all)
11986     return FALSE;
11987
11988   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
11989     return FALSE;
11990
11991   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
11992   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
11993     return FALSE;
11994
11995
11996    if (node->children && open_all)
11997     {
11998       gboolean retval = FALSE;
11999       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12000
12001       gtk_tree_path_append_index (tmp_path, 0);
12002       tree = node->children;
12003       node = tree->root;
12004       while (node->left != tree->nil)
12005         node = node->left;
12006       /* try to expand the children */
12007       do
12008         {
12009          gboolean t;
12010          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12011                                             TRUE, animate);
12012          if (t)
12013            retval = TRUE;
12014
12015          gtk_tree_path_next (tmp_path);
12016          node = _gtk_rbtree_next (tree, node);
12017        }
12018       while (node != NULL);
12019
12020       gtk_tree_path_free (tmp_path);
12021
12022       return retval;
12023     }
12024
12025   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12026
12027   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12028     return FALSE;
12029
12030   if (expand)
12031     return FALSE;
12032
12033   node->children = _gtk_rbtree_new ();
12034   node->children->parent_tree = tree;
12035   node->children->parent_node = node;
12036
12037   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12038
12039   gtk_tree_view_build_tree (tree_view,
12040                             node->children,
12041                             &temp,
12042                             gtk_tree_path_get_depth (path) + 1,
12043                             open_all);
12044
12045   remove_expand_collapse_timeout (tree_view);
12046
12047   if (animate)
12048     add_expand_collapse_timeout (tree_view, tree, node, TRUE);
12049
12050   install_presize_handler (tree_view);
12051
12052   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12053   if (open_all && node->children)
12054     {
12055       _gtk_rbtree_traverse (node->children,
12056                             node->children->root,
12057                             G_PRE_ORDER,
12058                             gtk_tree_view_expand_all_emission_helper,
12059                             tree_view);
12060     }
12061   return TRUE;
12062 }
12063
12064
12065 /**
12066  * gtk_tree_view_expand_row:
12067  * @tree_view: a #GtkTreeView
12068  * @path: path to a row
12069  * @open_all: whether to recursively expand, or just expand immediate children
12070  *
12071  * Opens the row so its children are visible.
12072  *
12073  * Return value: %TRUE if the row existed and had children
12074  **/
12075 gboolean
12076 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12077                           GtkTreePath *path,
12078                           gboolean     open_all)
12079 {
12080   GtkRBTree *tree;
12081   GtkRBNode *node;
12082
12083   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12084   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12085   g_return_val_if_fail (path != NULL, FALSE);
12086
12087   if (_gtk_tree_view_find_node (tree_view,
12088                                 path,
12089                                 &tree,
12090                                 &node))
12091     return FALSE;
12092
12093   if (tree != NULL)
12094     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12095   else
12096     return FALSE;
12097 }
12098
12099 static gboolean
12100 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12101                                  GtkTreePath *path,
12102                                  GtkRBTree   *tree,
12103                                  GtkRBNode   *node,
12104                                  gboolean     animate)
12105 {
12106   GtkTreeIter iter;
12107   GtkTreeIter children;
12108   gboolean collapse;
12109   gint x, y;
12110   GList *list;
12111   GdkWindow *child, *parent;
12112
12113   if (animate)
12114     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12115                   "gtk-enable-animations", &animate,
12116                   NULL);
12117
12118   remove_auto_expand_timeout (tree_view);
12119
12120   if (node->children == NULL)
12121     return FALSE;
12122
12123   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12124
12125   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12126
12127   if (collapse)
12128     return FALSE;
12129
12130   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12131    * a chance to prelight the correct node below */
12132
12133   if (tree_view->priv->prelight_tree)
12134     {
12135       GtkRBTree *parent_tree;
12136       GtkRBNode *parent_node;
12137
12138       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12139       parent_node = tree_view->priv->prelight_tree->parent_node;
12140       while (parent_tree)
12141         {
12142           if (parent_tree == tree && parent_node == node)
12143             {
12144               ensure_unprelighted (tree_view);
12145               break;
12146             }
12147           parent_node = parent_tree->parent_node;
12148           parent_tree = parent_tree->parent_tree;
12149         }
12150     }
12151
12152   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12153
12154   for (list = tree_view->priv->columns; list; list = list->next)
12155     {
12156       GtkTreeViewColumn *column = list->data;
12157
12158       if (column->visible == FALSE)
12159         continue;
12160       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12161         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12162     }
12163
12164   if (tree_view->priv->destroy_count_func)
12165     {
12166       GtkTreePath *child_path;
12167       gint child_count = 0;
12168       child_path = gtk_tree_path_copy (path);
12169       gtk_tree_path_down (child_path);
12170       if (node->children)
12171         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12172       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12173       gtk_tree_path_free (child_path);
12174     }
12175
12176   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12177     {
12178       GtkTreePath *cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12179
12180       if (gtk_tree_path_is_ancestor (path, cursor_path))
12181         {
12182           gtk_tree_row_reference_free (tree_view->priv->cursor);
12183           tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
12184                                                                       tree_view->priv->model,
12185                                                                       path);
12186         }
12187       gtk_tree_path_free (cursor_path);
12188     }
12189
12190   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12191     {
12192       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12193       if (gtk_tree_path_is_ancestor (path, anchor_path))
12194         {
12195           gtk_tree_row_reference_free (tree_view->priv->anchor);
12196           tree_view->priv->anchor = NULL;
12197         }
12198       gtk_tree_path_free (anchor_path);
12199     }
12200
12201   /* Stop a pending double click */
12202   tree_view->priv->last_button_x = -1;
12203   tree_view->priv->last_button_y = -1;
12204
12205   remove_expand_collapse_timeout (tree_view);
12206
12207   if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children))
12208     {
12209       _gtk_rbtree_remove (node->children);
12210       g_signal_emit_by_name (tree_view->priv->selection, "changed");
12211     }
12212   else
12213     _gtk_rbtree_remove (node->children);
12214
12215   if (animate)
12216     add_expand_collapse_timeout (tree_view, tree, node, FALSE);
12217
12218   if (GTK_WIDGET_MAPPED (tree_view))
12219     {
12220       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12221     }
12222
12223   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12224
12225   if (GTK_WIDGET_MAPPED (tree_view))
12226     {
12227       /* now that we've collapsed all rows, we want to try to set the prelight
12228        * again. To do this, we fake a motion event and send it to ourselves. */
12229
12230       child = tree_view->priv->bin_window;
12231       parent = gdk_window_get_parent (child);
12232
12233       if (gdk_window_get_pointer (parent, &x, &y, NULL) == child)
12234         {
12235           GdkEventMotion event;
12236           gint child_x, child_y;
12237
12238           gdk_window_get_position (child, &child_x, &child_y);
12239
12240           event.window = tree_view->priv->bin_window;
12241           event.x = x - child_x;
12242           event.y = y - child_y;
12243
12244           /* despite the fact this isn't a real event, I'm almost positive it will
12245            * never trigger a drag event.  maybe_drag is the only function that uses
12246            * more than just event.x and event.y. */
12247           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
12248         }
12249     }
12250
12251   return TRUE;
12252 }
12253
12254 /**
12255  * gtk_tree_view_collapse_row:
12256  * @tree_view: a #GtkTreeView
12257  * @path: path to a row in the @tree_view
12258  *
12259  * Collapses a row (hides its child rows, if they exist).
12260  *
12261  * Return value: %TRUE if the row was collapsed.
12262  **/
12263 gboolean
12264 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
12265                             GtkTreePath *path)
12266 {
12267   GtkRBTree *tree;
12268   GtkRBNode *node;
12269
12270   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12271   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
12272   g_return_val_if_fail (path != NULL, FALSE);
12273
12274   if (_gtk_tree_view_find_node (tree_view,
12275                                 path,
12276                                 &tree,
12277                                 &node))
12278     return FALSE;
12279
12280   if (tree == NULL || node->children == NULL)
12281     return FALSE;
12282
12283   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12284 }
12285
12286 static void
12287 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
12288                                         GtkRBTree              *tree,
12289                                         GtkTreePath            *path,
12290                                         GtkTreeViewMappingFunc  func,
12291                                         gpointer                user_data)
12292 {
12293   GtkRBNode *node;
12294
12295   if (tree == NULL || tree->root == NULL)
12296     return;
12297
12298   node = tree->root;
12299
12300   while (node && node->left != tree->nil)
12301     node = node->left;
12302
12303   while (node)
12304     {
12305       if (node->children)
12306         {
12307           (* func) (tree_view, path, user_data);
12308           gtk_tree_path_down (path);
12309           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
12310           gtk_tree_path_up (path);
12311         }
12312       gtk_tree_path_next (path);
12313       node = _gtk_rbtree_next (tree, node);
12314     }
12315 }
12316
12317 /**
12318  * gtk_tree_view_map_expanded_rows:
12319  * @tree_view: A #GtkTreeView
12320  * @func: A function to be called
12321  * @data: User data to be passed to the function.
12322  *
12323  * Calls @func on all expanded rows.
12324  **/
12325 void
12326 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
12327                                  GtkTreeViewMappingFunc  func,
12328                                  gpointer                user_data)
12329 {
12330   GtkTreePath *path;
12331
12332   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12333   g_return_if_fail (func != NULL);
12334
12335   path = gtk_tree_path_new_first ();
12336
12337   gtk_tree_view_map_expanded_rows_helper (tree_view,
12338                                           tree_view->priv->tree,
12339                                           path, func, user_data);
12340
12341   gtk_tree_path_free (path);
12342 }
12343
12344 /**
12345  * gtk_tree_view_row_expanded:
12346  * @tree_view: A #GtkTreeView.
12347  * @path: A #GtkTreePath to test expansion state.
12348  *
12349  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
12350  *
12351  * Return value: %TRUE if #path is expanded.
12352  **/
12353 gboolean
12354 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
12355                             GtkTreePath *path)
12356 {
12357   GtkRBTree *tree;
12358   GtkRBNode *node;
12359
12360   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12361   g_return_val_if_fail (path != NULL, FALSE);
12362
12363   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12364
12365   if (node == NULL)
12366     return FALSE;
12367
12368   return (node->children != NULL);
12369 }
12370
12371 /**
12372  * gtk_tree_view_get_reorderable:
12373  * @tree_view: a #GtkTreeView
12374  *
12375  * Retrieves whether the user can reorder the tree via drag-and-drop. See
12376  * gtk_tree_view_set_reorderable().
12377  *
12378  * Return value: %TRUE if the tree can be reordered.
12379  **/
12380 gboolean
12381 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
12382 {
12383   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12384
12385   return tree_view->priv->reorderable;
12386 }
12387
12388 /**
12389  * gtk_tree_view_set_reorderable:
12390  * @tree_view: A #GtkTreeView.
12391  * @reorderable: %TRUE, if the tree can be reordered.
12392  *
12393  * This function is a convenience function to allow you to reorder
12394  * models that support the #GtkDragSourceIface and the
12395  * #GtkDragDestIface.  Both #GtkTreeStore and #GtkListStore support
12396  * these.  If @reorderable is %TRUE, then the user can reorder the
12397  * model by dragging and dropping rows. The developer can listen to
12398  * these changes by connecting to the model's row_inserted and
12399  * row_deleted signals. The reordering is implemented by setting up
12400  * the tree view as a drag source and destination. Therefore, drag and
12401  * drop can not be used in a reorderable view for any other purpose.
12402  *
12403  * This function does not give you any degree of control over the order -- any
12404  * reordering is allowed.  If more control is needed, you should probably
12405  * handle drag and drop manually.
12406  **/
12407 void
12408 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
12409                                gboolean     reorderable)
12410 {
12411   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12412
12413   reorderable = reorderable != FALSE;
12414
12415   if (tree_view->priv->reorderable == reorderable)
12416     return;
12417
12418   if (reorderable)
12419     {
12420       const GtkTargetEntry row_targets[] = {
12421         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
12422       };
12423
12424       gtk_tree_view_enable_model_drag_source (tree_view,
12425                                               GDK_BUTTON1_MASK,
12426                                               row_targets,
12427                                               G_N_ELEMENTS (row_targets),
12428                                               GDK_ACTION_MOVE);
12429       gtk_tree_view_enable_model_drag_dest (tree_view,
12430                                             row_targets,
12431                                             G_N_ELEMENTS (row_targets),
12432                                             GDK_ACTION_MOVE);
12433     }
12434   else
12435     {
12436       gtk_tree_view_unset_rows_drag_source (tree_view);
12437       gtk_tree_view_unset_rows_drag_dest (tree_view);
12438     }
12439
12440   tree_view->priv->reorderable = reorderable;
12441
12442   g_object_notify (G_OBJECT (tree_view), "reorderable");
12443 }
12444
12445 static void
12446 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
12447                                GtkTreePath     *path,
12448                                gboolean         clear_and_select,
12449                                gboolean         clamp_node)
12450 {
12451   GtkRBTree *tree = NULL;
12452   GtkRBNode *node = NULL;
12453
12454   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12455     {
12456       GtkTreePath *cursor_path;
12457       cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12458       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
12459       gtk_tree_path_free (cursor_path);
12460     }
12461
12462   gtk_tree_row_reference_free (tree_view->priv->cursor);
12463   tree_view->priv->cursor = NULL;
12464
12465   /* One cannot set the cursor on a separator.   Also, if
12466    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
12467    * before finding the tree and node belonging to path.  The
12468    * path maps to a non-existing path and we will silently bail out.
12469    * We unset tree and node to avoid further processing.
12470    */
12471   if (!row_is_separator (tree_view, NULL, path)
12472       && _gtk_tree_view_find_node (tree_view, path, &tree, &node) == FALSE)
12473     {
12474       tree_view->priv->cursor =
12475           gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
12476                                             tree_view->priv->model,
12477                                             path);
12478     }
12479   else
12480     {
12481       tree = NULL;
12482       node = NULL;
12483     }
12484
12485   if (tree != NULL)
12486     {
12487       GtkRBTree *new_tree = NULL;
12488       GtkRBNode *new_node = NULL;
12489
12490       if (clear_and_select && !tree_view->priv->ctrl_pressed)
12491         {
12492           GtkTreeSelectMode mode = 0;
12493
12494           if (tree_view->priv->ctrl_pressed)
12495             mode |= GTK_TREE_SELECT_MODE_TOGGLE;
12496           if (tree_view->priv->shift_pressed)
12497             mode |= GTK_TREE_SELECT_MODE_EXTEND;
12498
12499           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
12500                                                     node, tree, path, mode,
12501                                                     FALSE);
12502         }
12503
12504       /* We have to re-find tree and node here again, somebody might have
12505        * cleared the node or the whole tree in the GtkTreeSelection::changed
12506        * callback. If the nodes differ we bail out here.
12507        */
12508       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
12509
12510       if (tree != new_tree || node != new_node)
12511         return;
12512
12513       if (clamp_node)
12514         {
12515           gtk_tree_view_clamp_node_visible (tree_view, tree, node);
12516           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
12517         }
12518     }
12519
12520   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
12521 }
12522
12523 /**
12524  * gtk_tree_view_get_cursor:
12525  * @tree_view: A #GtkTreeView
12526  * @path: A pointer to be filled with the current cursor path, or %NULL
12527  * @focus_column: A pointer to be filled with the current focus column, or %NULL
12528  *
12529  * Fills in @path and @focus_column with the current path and focus column.  If
12530  * the cursor isn't currently set, then *@path will be %NULL.  If no column
12531  * currently has focus, then *@focus_column will be %NULL.
12532  *
12533  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
12534  * you are done with it.
12535  **/
12536 void
12537 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
12538                           GtkTreePath       **path,
12539                           GtkTreeViewColumn **focus_column)
12540 {
12541   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12542
12543   if (path)
12544     {
12545       if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12546         *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12547       else
12548         *path = NULL;
12549     }
12550
12551   if (focus_column)
12552     {
12553       *focus_column = tree_view->priv->focus_column;
12554     }
12555 }
12556
12557 /**
12558  * gtk_tree_view_set_cursor:
12559  * @tree_view: A #GtkTreeView
12560  * @path: A #GtkTreePath
12561  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
12562  * @start_editing: %TRUE if the specified cell should start being edited.
12563  *
12564  * Sets the current keyboard focus to be at @path, and selects it.  This is
12565  * useful when you want to focus the user's attention on a particular row.  If
12566  * @focus_column is not %NULL, then focus is given to the column specified by
12567  * it. Additionally, if @focus_column is specified, and @start_editing is
12568  * %TRUE, then editing should be started in the specified cell.
12569  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
12570  * in order to give keyboard focus to the widget.  Please note that editing
12571  * can only happen when the widget is realized.
12572  *
12573  * If @path is invalid for @model, the current cursor (if any) will be unset
12574  * and the function will return without failing.
12575  **/
12576 void
12577 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
12578                           GtkTreePath       *path,
12579                           GtkTreeViewColumn *focus_column,
12580                           gboolean           start_editing)
12581 {
12582   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
12583                                     NULL, start_editing);
12584 }
12585
12586 /**
12587  * gtk_tree_view_set_cursor_on_cell:
12588  * @tree_view: A #GtkTreeView
12589  * @path: A #GtkTreePath
12590  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
12591  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
12592  * @start_editing: %TRUE if the specified cell should start being edited.
12593  *
12594  * Sets the current keyboard focus to be at @path, and selects it.  This is
12595  * useful when you want to focus the user's attention on a particular row.  If
12596  * @focus_column is not %NULL, then focus is given to the column specified by
12597  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
12598  * contains 2 or more editable or activatable cells, then focus is given to
12599  * the cell specified by @focus_cell. Additionally, if @focus_column is
12600  * specified, and @start_editing is %TRUE, then editing should be started in
12601  * the specified cell.  This function is often followed by
12602  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
12603  * widget.  Please note that editing can only happen when the widget is
12604  * realized.
12605  *
12606  * If @path is invalid for @model, the current cursor (if any) will be unset
12607  * and the function will return without failing.
12608  *
12609  * Since: 2.2
12610  **/
12611 void
12612 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
12613                                   GtkTreePath       *path,
12614                                   GtkTreeViewColumn *focus_column,
12615                                   GtkCellRenderer   *focus_cell,
12616                                   gboolean           start_editing)
12617 {
12618   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12619   g_return_if_fail (path != NULL);
12620   g_return_if_fail (focus_column == NULL || GTK_IS_TREE_VIEW_COLUMN (focus_column));
12621
12622   if (!tree_view->priv->model)
12623     return;
12624
12625   if (focus_cell)
12626     {
12627       g_return_if_fail (focus_column);
12628       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
12629     }
12630
12631   /* cancel the current editing, if it exists */
12632   if (tree_view->priv->edited_column &&
12633       tree_view->priv->edited_column->editable_widget)
12634     gtk_tree_view_stop_editing (tree_view, TRUE);
12635
12636   gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
12637
12638   if (focus_column && focus_column->visible)
12639     {
12640       GList *list;
12641       gboolean column_in_tree = FALSE;
12642
12643       for (list = tree_view->priv->columns; list; list = list->next)
12644         if (list->data == focus_column)
12645           {
12646             column_in_tree = TRUE;
12647             break;
12648           }
12649       g_return_if_fail (column_in_tree);
12650       tree_view->priv->focus_column = focus_column;
12651       if (focus_cell)
12652         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
12653       if (start_editing)
12654         gtk_tree_view_start_editing (tree_view, path);
12655     }
12656 }
12657
12658 /**
12659  * gtk_tree_view_get_bin_window:
12660  * @tree_view: A #GtkTreeView
12661  *
12662  * Returns the window that @tree_view renders to.  This is used primarily to
12663  * compare to <literal>event->window</literal> to confirm that the event on
12664  * @tree_view is on the right window.
12665  *
12666  * Return value: A #GdkWindow, or %NULL when @tree_view hasn't been realized yet
12667  **/
12668 GdkWindow *
12669 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
12670 {
12671   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12672
12673   return tree_view->priv->bin_window;
12674 }
12675
12676 /**
12677  * gtk_tree_view_get_path_at_pos:
12678  * @tree_view: A #GtkTreeView.
12679  * @x: The x position to be identified (relative to bin_window).
12680  * @y: The y position to be identified (relative to bin_window).
12681  * @path: A pointer to a #GtkTreePath pointer to be filled in, or %NULL
12682  * @column: A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
12683  * @cell_x: A pointer where the X coordinate relative to the cell can be placed, or %NULL
12684  * @cell_y: A pointer where the Y coordinate relative to the cell can be placed, or %NULL
12685  *
12686  * Finds the path at the point (@x, @y), relative to bin_window coordinates
12687  * (please see gtk_tree_view_get_bin_window()).
12688  * That is, @x and @y are relative to an events coordinates. @x and @y must
12689  * come from an event on the @tree_view only where <literal>event->window ==
12690  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
12691  * things like popup menus. If @path is non-%NULL, then it will be filled
12692  * with the #GtkTreePath at that point.  This path should be freed with
12693  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
12694  * with the column at that point.  @cell_x and @cell_y return the coordinates
12695  * relative to the cell background (i.e. the @background_area passed to
12696  * gtk_cell_renderer_render()).  This function is only meaningful if
12697  * @tree_view is realized.  Therefore this function will always return %FALSE
12698  * if @tree_view is not realized or does not have a model.
12699  *
12700  * For converting widget coordinates (eg. the ones you get from
12701  * GtkWidget::query-tooltip), please see
12702  * gtk_tree_view_convert_widget_to_bin_window_coords().
12703  *
12704  * Return value: %TRUE if a row exists at that coordinate.
12705  **/
12706 gboolean
12707 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
12708                                gint                x,
12709                                gint                y,
12710                                GtkTreePath       **path,
12711                                GtkTreeViewColumn **column,
12712                                gint               *cell_x,
12713                                gint               *cell_y)
12714 {
12715   GtkRBTree *tree;
12716   GtkRBNode *node;
12717   gint y_offset;
12718
12719   g_return_val_if_fail (tree_view != NULL, FALSE);
12720
12721   if (path)
12722     *path = NULL;
12723   if (column)
12724     *column = NULL;
12725
12726   if (tree_view->priv->bin_window == NULL)
12727     return FALSE;
12728
12729   if (tree_view->priv->tree == NULL)
12730     return FALSE;
12731
12732   if (x > tree_view->priv->hadjustment->upper)
12733     return FALSE;
12734
12735   if (x < 0 || y < 0)
12736     return FALSE;
12737
12738   if (column || cell_x)
12739     {
12740       GtkTreeViewColumn *tmp_column;
12741       GtkTreeViewColumn *last_column = NULL;
12742       GList *list;
12743       gint remaining_x = x;
12744       gboolean found = FALSE;
12745       gboolean rtl;
12746
12747       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
12748       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
12749            list;
12750            list = (rtl ? list->prev : list->next))
12751         {
12752           tmp_column = list->data;
12753
12754           if (tmp_column->visible == FALSE)
12755             continue;
12756
12757           last_column = tmp_column;
12758           if (remaining_x <= tmp_column->width)
12759             {
12760               found = TRUE;
12761
12762               if (column)
12763                 *column = tmp_column;
12764
12765               if (cell_x)
12766                 *cell_x = remaining_x;
12767
12768               break;
12769             }
12770           remaining_x -= tmp_column->width;
12771         }
12772
12773       /* If found is FALSE and there is a last_column, then it the remainder
12774        * space is in that area
12775        */
12776       if (!found)
12777         {
12778           if (last_column)
12779             {
12780               if (column)
12781                 *column = last_column;
12782
12783               if (cell_x)
12784                 *cell_x = last_column->width + remaining_x;
12785             }
12786           else
12787             {
12788               return FALSE;
12789             }
12790         }
12791     }
12792
12793   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
12794                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
12795                                       &tree, &node);
12796
12797   if (tree == NULL)
12798     return FALSE;
12799
12800   if (cell_y)
12801     *cell_y = y_offset;
12802
12803   if (path)
12804     *path = _gtk_tree_view_find_path (tree_view, tree, node);
12805
12806   return TRUE;
12807 }
12808
12809
12810 /**
12811  * gtk_tree_view_get_cell_area:
12812  * @tree_view: a #GtkTreeView
12813  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
12814  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
12815  * @rect: rectangle to fill with cell rect
12816  *
12817  * Fills the bounding rectangle in bin_window coordinates for the cell at the
12818  * row specified by @path and the column specified by @column.  If @path is
12819  * %NULL, or points to a path not currently displayed, the @y and @height fields
12820  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
12821  * fields will be filled with 0.  The sum of all cell rects does not cover the
12822  * entire tree; there are extra pixels in between rows, for example. The
12823  * returned rectangle is equivalent to the @cell_area passed to
12824  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
12825  * realized.
12826  **/
12827 void
12828 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
12829                              GtkTreePath        *path,
12830                              GtkTreeViewColumn  *column,
12831                              GdkRectangle       *rect)
12832 {
12833   GtkRBTree *tree = NULL;
12834   GtkRBNode *node = NULL;
12835   gint vertical_separator;
12836   gint horizontal_separator;
12837
12838   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12839   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12840   g_return_if_fail (rect != NULL);
12841   g_return_if_fail (!column || column->tree_view == (GtkWidget *) tree_view);
12842   g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
12843
12844   gtk_widget_style_get (GTK_WIDGET (tree_view),
12845                         "vertical-separator", &vertical_separator,
12846                         "horizontal-separator", &horizontal_separator,
12847                         NULL);
12848
12849   rect->x = 0;
12850   rect->y = 0;
12851   rect->width = 0;
12852   rect->height = 0;
12853
12854   if (column)
12855     {
12856       rect->x = column->button->allocation.x + horizontal_separator/2;
12857       rect->width = column->button->allocation.width - horizontal_separator;
12858     }
12859
12860   if (path)
12861     {
12862       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12863
12864       /* Get vertical coords */
12865       if ((!ret && tree == NULL) || ret)
12866         return;
12867
12868       rect->y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
12869       rect->height = MAX (CELL_HEIGHT (node, vertical_separator), tree_view->priv->expander_size - vertical_separator);
12870
12871       if (column &&
12872           gtk_tree_view_is_expander_column (tree_view, column))
12873         {
12874           gint depth = gtk_tree_path_get_depth (path);
12875           gboolean rtl;
12876
12877           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
12878
12879           if (!rtl)
12880             rect->x += (depth - 1) * tree_view->priv->level_indentation;
12881           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
12882
12883           if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
12884             {
12885               if (!rtl)
12886                 rect->x += depth * tree_view->priv->expander_size;
12887               rect->width -= depth * tree_view->priv->expander_size;
12888             }
12889
12890           rect->width = MAX (rect->width, 0);
12891         }
12892     }
12893 }
12894
12895 /**
12896  * gtk_tree_view_get_background_area:
12897  * @tree_view: a #GtkTreeView
12898  * @path: a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
12899  * @column: a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
12900  * @rect: rectangle to fill with cell background rect
12901  *
12902  * Fills the bounding rectangle in bin_window coordinates for the cell at the
12903  * row specified by @path and the column specified by @column.  If @path is
12904  * %NULL, or points to a node not found in the tree, the @y and @height fields of
12905  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
12906  * fields will be filled with 0.  The returned rectangle is equivalent to the
12907  * @background_area passed to gtk_cell_renderer_render().  These background
12908  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
12909  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
12910  * itself, excluding surrounding borders and the tree expander area.
12911  *
12912  **/
12913 void
12914 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
12915                                    GtkTreePath        *path,
12916                                    GtkTreeViewColumn  *column,
12917                                    GdkRectangle       *rect)
12918 {
12919   GtkRBTree *tree = NULL;
12920   GtkRBNode *node = NULL;
12921
12922   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12923   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12924   g_return_if_fail (rect != NULL);
12925
12926   rect->x = 0;
12927   rect->y = 0;
12928   rect->width = 0;
12929   rect->height = 0;
12930
12931   if (path)
12932     {
12933       /* Get vertical coords */
12934
12935       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
12936           tree == NULL)
12937         return;
12938
12939       rect->y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
12940
12941       rect->height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
12942     }
12943
12944   if (column)
12945     {
12946       gint x2 = 0;
12947
12948       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
12949       rect->width = x2 - rect->x;
12950     }
12951 }
12952
12953 /**
12954  * gtk_tree_view_get_visible_rect:
12955  * @tree_view: a #GtkTreeView
12956  * @visible_rect: rectangle to fill
12957  *
12958  * Fills @visible_rect with the currently-visible region of the
12959  * buffer, in tree coordinates. Convert to bin_window coordinates with
12960  * gtk_tree_view_convert_tree_to_bin_window_coords().
12961  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
12962  * scrollable area of the tree.
12963  **/
12964 void
12965 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
12966                                 GdkRectangle *visible_rect)
12967 {
12968   GtkWidget *widget;
12969
12970   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12971
12972   widget = GTK_WIDGET (tree_view);
12973
12974   if (visible_rect)
12975     {
12976       visible_rect->x = tree_view->priv->hadjustment->value;
12977       visible_rect->y = tree_view->priv->vadjustment->value;
12978       visible_rect->width = widget->allocation.width;
12979       visible_rect->height = widget->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
12980     }
12981 }
12982
12983 /**
12984  * gtk_tree_view_widget_to_tree_coords:
12985  * @tree_view: a #GtkTreeView
12986  * @wx: X coordinate relative to bin_window
12987  * @wy: Y coordinate relative to bin_window
12988  * @tx: return location for tree X coordinate
12989  * @ty: return location for tree Y coordinate
12990  *
12991  * Converts bin_window coordinates to coordinates for the
12992  * tree (the full scrollable area of the tree).
12993  *
12994  * Deprecated: 2.12: Due to historial reasons the name of this function is
12995  * incorrect.  For converting coordinates relative to the widget to
12996  * bin_window coordinates, please see
12997  * gtk_tree_view_convert_widget_to_bin_window_coords().
12998  *
12999  **/
13000 void
13001 gtk_tree_view_widget_to_tree_coords (GtkTreeView *tree_view,
13002                                       gint         wx,
13003                                       gint         wy,
13004                                       gint        *tx,
13005                                       gint        *ty)
13006 {
13007   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13008
13009   if (tx)
13010     *tx = wx + tree_view->priv->hadjustment->value;
13011   if (ty)
13012     *ty = wy + tree_view->priv->dy;
13013 }
13014
13015 /**
13016  * gtk_tree_view_tree_to_widget_coords:
13017  * @tree_view: a #GtkTreeView
13018  * @tx: tree X coordinate
13019  * @ty: tree Y coordinate
13020  * @wx: return location for X coordinate relative to bin_window
13021  * @wy: return location for Y coordinate relative to bin_window
13022  *
13023  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13024  * to bin_window coordinates.
13025  *
13026  * Deprecated: 2.12: Due to historial reasons the name of this function is
13027  * incorrect.  For converting bin_window coordinates to coordinates relative
13028  * to bin_window, please see
13029  * gtk_tree_view_convert_bin_window_to_widget_coords().
13030  *
13031  **/
13032 void
13033 gtk_tree_view_tree_to_widget_coords (GtkTreeView *tree_view,
13034                                      gint         tx,
13035                                      gint         ty,
13036                                      gint        *wx,
13037                                      gint        *wy)
13038 {
13039   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13040
13041   if (wx)
13042     *wx = tx - tree_view->priv->hadjustment->value;
13043   if (wy)
13044     *wy = ty - tree_view->priv->dy;
13045 }
13046
13047
13048 /**
13049  * gtk_tree_view_convert_widget_to_tree_coords:
13050  * @tree_view: a #GtkTreeView
13051  * @wx: X coordinate relative to the widget
13052  * @wy: Y coordinate relative to the widget
13053  * @tx: return location for tree X coordinate
13054  * @ty: return location for tree Y coordinate
13055  *
13056  * Converts widget coordinates to coordinates for the
13057  * tree (the full scrollable area of the tree).
13058  *
13059  * Since: 2.12
13060  **/
13061 void
13062 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13063                                              gint         wx,
13064                                              gint         wy,
13065                                              gint        *tx,
13066                                              gint        *ty)
13067 {
13068   gint x, y;
13069
13070   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13071
13072   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13073                                                      wx, wy,
13074                                                      &x, &y);
13075   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13076                                                    x, y,
13077                                                    tx, ty);
13078 }
13079
13080 /**
13081  * gtk_tree_view_convert_tree_to_widget_coords:
13082  * @tree_view: a #GtkTreeView
13083  * @tx: X coordinate relative to the tree
13084  * @ty: Y coordinate relative to the tree
13085  * @wx: return location for widget X coordinate
13086  * @wy: return location for widget Y coordinate
13087  *
13088  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13089  * to widget coordinates.
13090  *
13091  * Since: 2.12
13092  **/
13093 void
13094 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13095                                              gint         tx,
13096                                              gint         ty,
13097                                              gint        *wx,
13098                                              gint        *wy)
13099 {
13100   gint x, y;
13101
13102   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13103
13104   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13105                                                    tx, ty,
13106                                                    &x, &y);
13107   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13108                                                      x, y,
13109                                                      wx, wy);
13110 }
13111
13112 /**
13113  * gtk_tree_view_convert_widget_to_bin_window_coords:
13114  * @tree_view: a #GtkTreeView
13115  * @wx: X coordinate relative to the widget
13116  * @wy: Y coordinate relative to the widget
13117  * @bx: return location for bin_window X coordinate
13118  * @by: return location for bin_window Y coordinate
13119  *
13120  * Converts widget coordinates to coordinates for the bin_window
13121  * (see gtk_tree_view_get_bin_window()).
13122  *
13123  * Since: 2.12
13124  **/
13125 void
13126 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13127                                                    gint         wx,
13128                                                    gint         wy,
13129                                                    gint        *bx,
13130                                                    gint        *by)
13131 {
13132   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13133
13134   if (bx)
13135     *bx = wx + tree_view->priv->hadjustment->value;
13136   if (by)
13137     *by = wy - TREE_VIEW_HEADER_HEIGHT (tree_view);
13138 }
13139
13140 /**
13141  * gtk_tree_view_convert_bin_window_to_widget_coords:
13142  * @tree_view: a #GtkTreeView
13143  * @bx: bin_window X coordinate
13144  * @by: bin_window Y coordinate
13145  * @wx: return location for widget X coordinate
13146  * @wy: return location for widget Y coordinate
13147  *
13148  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13149  * to widget relative coordinates.
13150  *
13151  * Since: 2.12
13152  **/
13153 void
13154 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13155                                                    gint         bx,
13156                                                    gint         by,
13157                                                    gint        *wx,
13158                                                    gint        *wy)
13159 {
13160   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13161
13162   if (wx)
13163     *wx = bx - tree_view->priv->hadjustment->value;
13164   if (wy)
13165     *wy = by + TREE_VIEW_HEADER_HEIGHT (tree_view);
13166 }
13167
13168 /**
13169  * gtk_tree_view_convert_tree_to_bin_window_coords:
13170  * @tree_view: a #GtkTreeView
13171  * @tx: tree X coordinate
13172  * @ty: tree Y coordinate
13173  * @bx: return location for X coordinate relative to bin_window
13174  * @by: return location for Y coordinate relative to bin_window
13175  *
13176  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13177  * to bin_window coordinates.
13178  *
13179  * Since: 2.12
13180  **/
13181 void
13182 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13183                                                  gint         tx,
13184                                                  gint         ty,
13185                                                  gint        *bx,
13186                                                  gint        *by)
13187 {
13188   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13189
13190   if (bx)
13191     *bx = tx;
13192   if (by)
13193     *by = ty - tree_view->priv->dy;
13194 }
13195
13196 /**
13197  * gtk_tree_view_convert_bin_window_to_tree_coords:
13198  * @tree_view: a #GtkTreeView
13199  * @bx: X coordinate relative to bin_window
13200  * @by: Y coordinate relative to bin_window
13201  * @tx: return location for tree X coordinate
13202  * @ty: return location for tree Y coordinate
13203  *
13204  * Converts bin_window coordinates to coordinates for the
13205  * tree (the full scrollable area of the tree).
13206  *
13207  * Since: 2.12
13208  **/
13209 void
13210 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
13211                                                  gint         bx,
13212                                                  gint         by,
13213                                                  gint        *tx,
13214                                                  gint        *ty)
13215 {
13216   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13217
13218   if (tx)
13219     *tx = bx;
13220   if (ty)
13221     *ty = by + tree_view->priv->dy;
13222 }
13223
13224
13225
13226 /**
13227  * gtk_tree_view_get_visible_range:
13228  * @tree_view: A #GtkTreeView
13229  * @start_path: Return location for start of region, or %NULL.
13230  * @end_path: Return location for end of region, or %NULL.
13231  *
13232  * Sets @start_path and @end_path to be the first and last visible path.
13233  * Note that there may be invisible paths in between.
13234  *
13235  * The paths should be freed with gtk_tree_path_free() after use.
13236  *
13237  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
13238  *
13239  * Since: 2.8
13240  **/
13241 gboolean
13242 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
13243                                  GtkTreePath **start_path,
13244                                  GtkTreePath **end_path)
13245 {
13246   GtkRBTree *tree;
13247   GtkRBNode *node;
13248   gboolean retval;
13249
13250   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13251
13252   if (!tree_view->priv->tree)
13253     return FALSE;
13254
13255   retval = TRUE;
13256
13257   if (start_path)
13258     {
13259       _gtk_rbtree_find_offset (tree_view->priv->tree,
13260                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
13261                                &tree, &node);
13262       if (node)
13263         *start_path = _gtk_tree_view_find_path (tree_view, tree, node);
13264       else
13265         retval = FALSE;
13266     }
13267
13268   if (end_path)
13269     {
13270       gint y;
13271
13272       if (tree_view->priv->height < tree_view->priv->vadjustment->page_size)
13273         y = tree_view->priv->height - 1;
13274       else
13275         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, tree_view->priv->vadjustment->page_size) - 1;
13276
13277       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
13278       if (node)
13279         *end_path = _gtk_tree_view_find_path (tree_view, tree, node);
13280       else
13281         retval = FALSE;
13282     }
13283
13284   return retval;
13285 }
13286
13287 static void
13288 unset_reorderable (GtkTreeView *tree_view)
13289 {
13290   if (tree_view->priv->reorderable)
13291     {
13292       tree_view->priv->reorderable = FALSE;
13293       g_object_notify (G_OBJECT (tree_view), "reorderable");
13294     }
13295 }
13296
13297 /**
13298  * gtk_tree_view_enable_model_drag_source:
13299  * @tree_view: a #GtkTreeView
13300  * @start_button_mask: Mask of allowed buttons to start drag
13301  * @targets: the table of targets that the drag will support
13302  * @n_targets: the number of items in @targets
13303  * @actions: the bitmask of possible actions for a drag from this
13304  *    widget
13305  *
13306  * Turns @tree_view into a drag source for automatic DND. Calling this
13307  * method sets #GtkTreeView:reorderable to %FALSE.
13308  **/
13309 void
13310 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
13311                                         GdkModifierType           start_button_mask,
13312                                         const GtkTargetEntry     *targets,
13313                                         gint                      n_targets,
13314                                         GdkDragAction             actions)
13315 {
13316   TreeViewDragInfo *di;
13317
13318   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13319
13320   gtk_drag_source_set (GTK_WIDGET (tree_view),
13321                        0,
13322                        targets,
13323                        n_targets,
13324                        actions);
13325
13326   di = ensure_info (tree_view);
13327
13328   di->start_button_mask = start_button_mask;
13329   di->source_actions = actions;
13330   di->source_set = TRUE;
13331
13332   unset_reorderable (tree_view);
13333 }
13334
13335 /**
13336  * gtk_tree_view_enable_model_drag_dest:
13337  * @tree_view: a #GtkTreeView
13338  * @targets: the table of targets that the drag will support
13339  * @n_targets: the number of items in @targets
13340  * @actions: the bitmask of possible actions for a drag from this
13341  *    widget
13342  *
13343  * Turns @tree_view into a drop destination for automatic DND. Calling
13344  * this method sets #GtkTreeView:reorderable to %FALSE.
13345  **/
13346 void
13347 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
13348                                       const GtkTargetEntry     *targets,
13349                                       gint                      n_targets,
13350                                       GdkDragAction             actions)
13351 {
13352   TreeViewDragInfo *di;
13353
13354   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13355
13356   gtk_drag_dest_set (GTK_WIDGET (tree_view),
13357                      0,
13358                      targets,
13359                      n_targets,
13360                      actions);
13361
13362   di = ensure_info (tree_view);
13363   di->dest_set = TRUE;
13364
13365   unset_reorderable (tree_view);
13366 }
13367
13368 /**
13369  * gtk_tree_view_unset_rows_drag_source:
13370  * @tree_view: a #GtkTreeView
13371  *
13372  * Undoes the effect of
13373  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
13374  * #GtkTreeView:reorderable to %FALSE.
13375  **/
13376 void
13377 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
13378 {
13379   TreeViewDragInfo *di;
13380
13381   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13382
13383   di = get_info (tree_view);
13384
13385   if (di)
13386     {
13387       if (di->source_set)
13388         {
13389           gtk_drag_source_unset (GTK_WIDGET (tree_view));
13390           di->source_set = FALSE;
13391         }
13392
13393       if (!di->dest_set && !di->source_set)
13394         remove_info (tree_view);
13395     }
13396
13397   unset_reorderable (tree_view);
13398 }
13399
13400 /**
13401  * gtk_tree_view_unset_rows_drag_dest:
13402  * @tree_view: a #GtkTreeView
13403  *
13404  * Undoes the effect of
13405  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
13406  * #GtkTreeView:reorderable to %FALSE.
13407  **/
13408 void
13409 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
13410 {
13411   TreeViewDragInfo *di;
13412
13413   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13414
13415   di = get_info (tree_view);
13416
13417   if (di)
13418     {
13419       if (di->dest_set)
13420         {
13421           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
13422           di->dest_set = FALSE;
13423         }
13424
13425       if (!di->dest_set && !di->source_set)
13426         remove_info (tree_view);
13427     }
13428
13429   unset_reorderable (tree_view);
13430 }
13431
13432 /**
13433  * gtk_tree_view_set_drag_dest_row:
13434  * @tree_view: a #GtkTreeView
13435  * @path: The path of the row to highlight, or %NULL.
13436  * @pos: Specifies whether to drop before, after or into the row
13437  *
13438  * Sets the row that is highlighted for feedback.
13439  **/
13440 void
13441 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
13442                                  GtkTreePath            *path,
13443                                  GtkTreeViewDropPosition pos)
13444 {
13445   GtkTreePath *current_dest;
13446
13447   /* Note; this function is exported to allow a custom DND
13448    * implementation, so it can't touch TreeViewDragInfo
13449    */
13450
13451   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13452
13453   current_dest = NULL;
13454
13455   if (tree_view->priv->drag_dest_row)
13456     {
13457       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
13458       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
13459     }
13460
13461   /* special case a drop on an empty model */
13462   tree_view->priv->empty_view_drop = 0;
13463
13464   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
13465       && gtk_tree_path_get_depth (path) == 1
13466       && gtk_tree_path_get_indices (path)[0] == 0)
13467     {
13468       gint n_children;
13469
13470       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
13471                                                    NULL);
13472
13473       if (!n_children)
13474         tree_view->priv->empty_view_drop = 1;
13475     }
13476
13477   tree_view->priv->drag_dest_pos = pos;
13478
13479   if (path)
13480     {
13481       tree_view->priv->drag_dest_row =
13482         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
13483       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
13484     }
13485   else
13486     tree_view->priv->drag_dest_row = NULL;
13487
13488   if (current_dest)
13489     {
13490       GtkRBTree *tree, *new_tree;
13491       GtkRBNode *node, *new_node;
13492
13493       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
13494       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
13495
13496       if (tree && node)
13497         {
13498           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
13499           if (new_tree && new_node)
13500             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
13501
13502           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
13503           if (new_tree && new_node)
13504             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
13505         }
13506       gtk_tree_path_free (current_dest);
13507     }
13508 }
13509
13510 /**
13511  * gtk_tree_view_get_drag_dest_row:
13512  * @tree_view: a #GtkTreeView
13513  * @path: Return location for the path of the highlighted row, or %NULL.
13514  * @pos: Return location for the drop position, or %NULL
13515  *
13516  * Gets information about the row that is highlighted for feedback.
13517  **/
13518 void
13519 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
13520                                  GtkTreePath             **path,
13521                                  GtkTreeViewDropPosition  *pos)
13522 {
13523   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13524
13525   if (path)
13526     {
13527       if (tree_view->priv->drag_dest_row)
13528         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
13529       else
13530         {
13531           if (tree_view->priv->empty_view_drop)
13532             *path = gtk_tree_path_new_from_indices (0, -1);
13533           else
13534             *path = NULL;
13535         }
13536     }
13537
13538   if (pos)
13539     *pos = tree_view->priv->drag_dest_pos;
13540 }
13541
13542 /**
13543  * gtk_tree_view_get_dest_row_at_pos:
13544  * @tree_view: a #GtkTreeView
13545  * @drag_x: the position to determine the destination row for
13546  * @drag_y: the position to determine the destination row for
13547  * @path: Return location for the path of the highlighted row, or %NULL.
13548  * @pos: Return location for the drop position, or %NULL
13549  *
13550  * Determines the destination row for a given position.  @drag_x and
13551  * @drag_y are expected to be in widget coordinates.  This function is only
13552  * meaningful if @tree_view is realized.  Therefore this function will always
13553  * return %FALSE if @tree_view is not realized or does not have a model.
13554  *
13555  * Return value: whether there is a row at the given position, %TRUE if this
13556  * is indeed the case.
13557  **/
13558 gboolean
13559 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
13560                                    gint                     drag_x,
13561                                    gint                     drag_y,
13562                                    GtkTreePath            **path,
13563                                    GtkTreeViewDropPosition *pos)
13564 {
13565   gint cell_y;
13566   gint bin_x, bin_y;
13567   gdouble offset_into_row;
13568   gdouble third;
13569   GdkRectangle cell;
13570   GtkTreeViewColumn *column = NULL;
13571   GtkTreePath *tmp_path = NULL;
13572
13573   /* Note; this function is exported to allow a custom DND
13574    * implementation, so it can't touch TreeViewDragInfo
13575    */
13576
13577   g_return_val_if_fail (tree_view != NULL, FALSE);
13578   g_return_val_if_fail (drag_x >= 0, FALSE);
13579   g_return_val_if_fail (drag_y >= 0, FALSE);
13580
13581   if (path)
13582     *path = NULL;
13583
13584   if (tree_view->priv->bin_window == NULL)
13585     return FALSE;
13586
13587   if (tree_view->priv->tree == NULL)
13588     return FALSE;
13589
13590   /* If in the top third of a row, we drop before that row; if
13591    * in the bottom third, drop after that row; if in the middle,
13592    * and the row has children, drop into the row.
13593    */
13594   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
13595                                                      &bin_x, &bin_y);
13596
13597   if (!gtk_tree_view_get_path_at_pos (tree_view,
13598                                       bin_x,
13599                                       bin_y,
13600                                       &tmp_path,
13601                                       &column,
13602                                       NULL,
13603                                       &cell_y))
13604     return FALSE;
13605
13606   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
13607                                      &cell);
13608
13609   offset_into_row = cell_y;
13610
13611   if (path)
13612     *path = tmp_path;
13613   else
13614     gtk_tree_path_free (tmp_path);
13615
13616   tmp_path = NULL;
13617
13618   third = cell.height / 3.0;
13619
13620   if (pos)
13621     {
13622       if (offset_into_row < third)
13623         {
13624           *pos = GTK_TREE_VIEW_DROP_BEFORE;
13625         }
13626       else if (offset_into_row < (cell.height / 2.0))
13627         {
13628           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
13629         }
13630       else if (offset_into_row < third * 2.0)
13631         {
13632           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
13633         }
13634       else
13635         {
13636           *pos = GTK_TREE_VIEW_DROP_AFTER;
13637         }
13638     }
13639
13640   return TRUE;
13641 }
13642
13643
13644
13645 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
13646 /**
13647  * gtk_tree_view_create_row_drag_icon:
13648  * @tree_view: a #GtkTreeView
13649  * @path: a #GtkTreePath in @tree_view
13650  *
13651  * Creates a #GdkPixmap representation of the row at @path.
13652  * This image is used for a drag icon.
13653  *
13654  * Return value: a newly-allocated pixmap of the drag icon.
13655  **/
13656 GdkPixmap *
13657 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
13658                                     GtkTreePath  *path)
13659 {
13660   GtkTreeIter   iter;
13661   GtkRBTree    *tree;
13662   GtkRBNode    *node;
13663   gint cell_offset;
13664   GList *list;
13665   GdkRectangle background_area;
13666   GdkRectangle expose_area;
13667   GtkWidget *widget;
13668   gint depth;
13669   /* start drawing inside the black outline */
13670   gint x = 1, y = 1;
13671   GdkDrawable *drawable;
13672   gint bin_window_width;
13673   gboolean is_separator = FALSE;
13674   gboolean rtl;
13675
13676   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13677   g_return_val_if_fail (path != NULL, NULL);
13678
13679   widget = GTK_WIDGET (tree_view);
13680
13681   if (!GTK_WIDGET_REALIZED (tree_view))
13682     return NULL;
13683
13684   depth = gtk_tree_path_get_depth (path);
13685
13686   _gtk_tree_view_find_node (tree_view,
13687                             path,
13688                             &tree,
13689                             &node);
13690
13691   if (tree == NULL)
13692     return NULL;
13693
13694   if (!gtk_tree_model_get_iter (tree_view->priv->model,
13695                                 &iter,
13696                                 path))
13697     return NULL;
13698
13699   is_separator = row_is_separator (tree_view, &iter, NULL);
13700
13701   cell_offset = x;
13702
13703   background_area.y = y;
13704   background_area.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
13705
13706   gdk_drawable_get_size (tree_view->priv->bin_window,
13707                          &bin_window_width, NULL);
13708
13709   drawable = gdk_pixmap_new (tree_view->priv->bin_window,
13710                              bin_window_width + 2,
13711                              background_area.height + 2,
13712                              -1);
13713
13714   expose_area.x = 0;
13715   expose_area.y = 0;
13716   expose_area.width = bin_window_width + 2;
13717   expose_area.height = background_area.height + 2;
13718
13719   gdk_draw_rectangle (drawable,
13720                       widget->style->base_gc [GTK_WIDGET_STATE (widget)],
13721                       TRUE,
13722                       0, 0,
13723                       bin_window_width + 2,
13724                       background_area.height + 2);
13725
13726   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13727
13728   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13729       list;
13730       list = (rtl ? list->prev : list->next))
13731     {
13732       GtkTreeViewColumn *column = list->data;
13733       GdkRectangle cell_area;
13734       gint vertical_separator;
13735
13736       if (!column->visible)
13737         continue;
13738
13739       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
13740                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
13741                                                node->children?TRUE:FALSE);
13742
13743       background_area.x = cell_offset;
13744       background_area.width = column->width;
13745
13746       gtk_widget_style_get (widget,
13747                             "vertical-separator", &vertical_separator,
13748                             NULL);
13749
13750       cell_area = background_area;
13751
13752       cell_area.y += vertical_separator / 2;
13753       cell_area.height -= vertical_separator;
13754
13755       if (gtk_tree_view_is_expander_column (tree_view, column))
13756         {
13757           if (!rtl)
13758             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
13759           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
13760
13761           if (TREE_VIEW_DRAW_EXPANDERS(tree_view))
13762             {
13763               if (!rtl)
13764                 cell_area.x += depth * tree_view->priv->expander_size;
13765               cell_area.width -= depth * tree_view->priv->expander_size;
13766             }
13767         }
13768
13769       if (gtk_tree_view_column_cell_is_visible (column))
13770         {
13771           if (is_separator)
13772             gtk_paint_hline (widget->style,
13773                              drawable,
13774                              GTK_STATE_NORMAL,
13775                              &cell_area,
13776                              widget,
13777                              NULL,
13778                              cell_area.x,
13779                              cell_area.x + cell_area.width,
13780                              cell_area.y + cell_area.height / 2);
13781           else
13782             _gtk_tree_view_column_cell_render (column,
13783                                                drawable,
13784                                                &background_area,
13785                                                &cell_area,
13786                                                &expose_area,
13787                                                0);
13788         }
13789       cell_offset += column->width;
13790     }
13791
13792   gdk_draw_rectangle (drawable,
13793                       widget->style->black_gc,
13794                       FALSE,
13795                       0, 0,
13796                       bin_window_width + 1,
13797                       background_area.height + 1);
13798
13799   return drawable;
13800 }
13801
13802
13803 /**
13804  * gtk_tree_view_set_destroy_count_func:
13805  * @tree_view: A #GtkTreeView
13806  * @func: Function to be called when a view row is destroyed, or %NULL
13807  * @data: User data to be passed to @func, or %NULL
13808  * @destroy: Destroy notifier for @data, or %NULL
13809  *
13810  * This function should almost never be used.  It is meant for private use by
13811  * ATK for determining the number of visible children that are removed when the
13812  * user collapses a row, or a row is deleted.
13813  **/
13814 void
13815 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
13816                                       GtkTreeDestroyCountFunc  func,
13817                                       gpointer                 data,
13818                                       GDestroyNotify           destroy)
13819 {
13820   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13821
13822   if (tree_view->priv->destroy_count_destroy)
13823     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
13824
13825   tree_view->priv->destroy_count_func = func;
13826   tree_view->priv->destroy_count_data = data;
13827   tree_view->priv->destroy_count_destroy = destroy;
13828 }
13829
13830
13831 /*
13832  * Interactive search
13833  */
13834
13835 /**
13836  * gtk_tree_view_set_enable_search:
13837  * @tree_view: A #GtkTreeView
13838  * @enable_search: %TRUE, if the user can search interactively
13839  *
13840  * If @enable_search is set, then the user can type in text to search through
13841  * the tree interactively (this is sometimes called "typeahead find").
13842  *
13843  * Note that even if this is %FALSE, the user can still initiate a search
13844  * using the "start-interactive-search" key binding.
13845  */
13846 void
13847 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
13848                                  gboolean     enable_search)
13849 {
13850   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13851
13852   enable_search = !!enable_search;
13853
13854   if (tree_view->priv->enable_search != enable_search)
13855     {
13856        tree_view->priv->enable_search = enable_search;
13857        g_object_notify (G_OBJECT (tree_view), "enable-search");
13858     }
13859 }
13860
13861 /**
13862  * gtk_tree_view_get_enable_search:
13863  * @tree_view: A #GtkTreeView
13864  *
13865  * Returns whether or not the tree allows to start interactive searching
13866  * by typing in text.
13867  *
13868  * Return value: whether or not to let the user search interactively
13869  */
13870 gboolean
13871 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
13872 {
13873   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13874
13875   return tree_view->priv->enable_search;
13876 }
13877
13878
13879 /**
13880  * gtk_tree_view_get_search_column:
13881  * @tree_view: A #GtkTreeView
13882  *
13883  * Gets the column searched on by the interactive search code.
13884  *
13885  * Return value: the column the interactive search code searches in.
13886  */
13887 gint
13888 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
13889 {
13890   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
13891
13892   return (tree_view->priv->search_column);
13893 }
13894
13895 /**
13896  * gtk_tree_view_set_search_column:
13897  * @tree_view: A #GtkTreeView
13898  * @column: the column of the model to search in, or -1 to disable searching
13899  *
13900  * Sets @column as the column where the interactive search code should
13901  * search in for the current model.
13902  *
13903  * If the search column is set, users can use the "start-interactive-search"
13904  * key binding to bring up search popup. The enable-search property controls
13905  * whether simply typing text will also start an interactive search.
13906  *
13907  * Note that @column refers to a column of the current model. The search
13908  * column is reset to -1 when the model is changed.
13909  */
13910 void
13911 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
13912                                  gint         column)
13913 {
13914   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13915   g_return_if_fail (column >= -1);
13916
13917   if (tree_view->priv->search_column == column)
13918     return;
13919
13920   tree_view->priv->search_column = column;
13921   g_object_notify (G_OBJECT (tree_view), "search-column");
13922 }
13923
13924 /**
13925  * gtk_tree_view_get_search_equal_func:
13926  * @tree_view: A #GtkTreeView
13927  *
13928  * Returns the compare function currently in use.
13929  *
13930  * Return value: the currently used compare function for the search code.
13931  */
13932
13933 GtkTreeViewSearchEqualFunc
13934 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
13935 {
13936   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13937
13938   return tree_view->priv->search_equal_func;
13939 }
13940
13941 /**
13942  * gtk_tree_view_set_search_equal_func:
13943  * @tree_view: A #GtkTreeView
13944  * @search_equal_func: the compare function to use during the search
13945  * @search_user_data: user data to pass to @search_equal_func, or %NULL
13946  * @search_destroy: Destroy notifier for @search_user_data, or %NULL
13947  *
13948  * Sets the compare function for the interactive search capabilities; note
13949  * that somewhat like strcmp() returning 0 for equality
13950  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
13951  **/
13952 void
13953 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
13954                                      GtkTreeViewSearchEqualFunc  search_equal_func,
13955                                      gpointer                    search_user_data,
13956                                      GDestroyNotify              search_destroy)
13957 {
13958   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13959   g_return_if_fail (search_equal_func != NULL);
13960
13961   if (tree_view->priv->search_destroy)
13962     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
13963
13964   tree_view->priv->search_equal_func = search_equal_func;
13965   tree_view->priv->search_user_data = search_user_data;
13966   tree_view->priv->search_destroy = search_destroy;
13967   if (tree_view->priv->search_equal_func == NULL)
13968     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
13969 }
13970
13971 /**
13972  * gtk_tree_view_get_search_entry:
13973  * @tree_view: A #GtkTreeView
13974  *
13975  * Returns the #GtkEntry which is currently in use as interactive search
13976  * entry for @tree_view.  In case the built-in entry is being used, %NULL
13977  * will be returned.
13978  *
13979  * Return value: the entry currently in use as search entry.
13980  *
13981  * Since: 2.10
13982  */
13983 GtkEntry *
13984 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
13985 {
13986   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13987
13988   if (tree_view->priv->search_custom_entry_set)
13989     return GTK_ENTRY (tree_view->priv->search_entry);
13990
13991   return NULL;
13992 }
13993
13994 /**
13995  * gtk_tree_view_set_search_entry:
13996  * @tree_view: A #GtkTreeView
13997  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
13998  *
13999  * Sets the entry which the interactive search code will use for this
14000  * @tree_view.  This is useful when you want to provide a search entry
14001  * in our interface at all time at a fixed position.  Passing %NULL for
14002  * @entry will make the interactive search code use the built-in popup
14003  * entry again.
14004  *
14005  * Since: 2.10
14006  */
14007 void
14008 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14009                                 GtkEntry    *entry)
14010 {
14011   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14012   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14013
14014   if (tree_view->priv->search_custom_entry_set)
14015     {
14016       if (tree_view->priv->search_entry_changed_id)
14017         {
14018           g_signal_handler_disconnect (tree_view->priv->search_entry,
14019                                        tree_view->priv->search_entry_changed_id);
14020           tree_view->priv->search_entry_changed_id = 0;
14021         }
14022       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14023                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14024                                             tree_view);
14025
14026       g_object_unref (tree_view->priv->search_entry);
14027     }
14028   else if (tree_view->priv->search_window)
14029     {
14030       gtk_widget_destroy (tree_view->priv->search_window);
14031
14032       tree_view->priv->search_window = NULL;
14033     }
14034
14035   if (entry)
14036     {
14037       tree_view->priv->search_entry = g_object_ref (entry);
14038       tree_view->priv->search_custom_entry_set = TRUE;
14039
14040       if (tree_view->priv->search_entry_changed_id == 0)
14041         {
14042           tree_view->priv->search_entry_changed_id =
14043             g_signal_connect (tree_view->priv->search_entry, "changed",
14044                               G_CALLBACK (gtk_tree_view_search_init),
14045                               tree_view);
14046         }
14047
14048         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14049                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14050                           tree_view);
14051
14052         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14053     }
14054   else
14055     {
14056       tree_view->priv->search_entry = NULL;
14057       tree_view->priv->search_custom_entry_set = FALSE;
14058     }
14059 }
14060
14061 /**
14062  * gtk_tree_view_set_search_position_func:
14063  * @tree_view: A #GtkTreeView
14064  * @func: the function to use to position the search dialog, or %NULL
14065  *    to use the default search position function
14066  * @data: user data to pass to @func, or %NULL
14067  * @destroy: Destroy notifier for @data, or %NULL
14068  *
14069  * Sets the function to use when positioning the search dialog.
14070  *
14071  * Since: 2.10
14072  **/
14073 void
14074 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
14075                                         GtkTreeViewSearchPositionFunc  func,
14076                                         gpointer                       user_data,
14077                                         GDestroyNotify                 destroy)
14078 {
14079   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14080
14081   if (tree_view->priv->search_position_destroy)
14082     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
14083
14084   tree_view->priv->search_position_func = func;
14085   tree_view->priv->search_position_user_data = user_data;
14086   tree_view->priv->search_position_destroy = destroy;
14087   if (tree_view->priv->search_position_func == NULL)
14088     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
14089 }
14090
14091 /**
14092  * gtk_tree_view_get_search_position_func:
14093  * @tree_view: A #GtkTreeView
14094  *
14095  * Returns the positioning function currently in use.
14096  *
14097  * Return value: the currently used function for positioning the search dialog.
14098  *
14099  * Since: 2.10
14100  */
14101 GtkTreeViewSearchPositionFunc
14102 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
14103 {
14104   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14105
14106   return tree_view->priv->search_position_func;
14107 }
14108
14109
14110 static void
14111 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
14112                                   GtkTreeView *tree_view)
14113 {
14114   if (tree_view->priv->disable_popdown)
14115     return;
14116
14117   if (tree_view->priv->search_entry_changed_id)
14118     {
14119       g_signal_handler_disconnect (tree_view->priv->search_entry,
14120                                    tree_view->priv->search_entry_changed_id);
14121       tree_view->priv->search_entry_changed_id = 0;
14122     }
14123   if (tree_view->priv->typeselect_flush_timeout)
14124     {
14125       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14126       tree_view->priv->typeselect_flush_timeout = 0;
14127     }
14128
14129   if (GTK_WIDGET_VISIBLE (search_dialog))
14130     {
14131       /* send focus-in event */
14132       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), FALSE);
14133       gtk_widget_hide (search_dialog);
14134       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
14135       send_focus_change (GTK_WIDGET (tree_view), TRUE);
14136     }
14137 }
14138
14139 static void
14140 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
14141                                     GtkWidget   *search_dialog,
14142                                     gpointer     user_data)
14143 {
14144   gint x, y;
14145   gint tree_x, tree_y;
14146   gint tree_width, tree_height;
14147   GdkWindow *tree_window = GTK_WIDGET (tree_view)->window;
14148   GdkScreen *screen = gdk_drawable_get_screen (tree_window);
14149   GtkRequisition requisition;
14150   gint monitor_num;
14151   GdkRectangle monitor;
14152
14153   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
14154   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
14155
14156   gtk_widget_realize (search_dialog);
14157
14158   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
14159   gdk_drawable_get_size (tree_window,
14160                          &tree_width,
14161                          &tree_height);
14162   gtk_widget_size_request (search_dialog, &requisition);
14163
14164   if (tree_x + tree_width > gdk_screen_get_width (screen))
14165     x = gdk_screen_get_width (screen) - requisition.width;
14166   else if (tree_x + tree_width - requisition.width < 0)
14167     x = 0;
14168   else
14169     x = tree_x + tree_width - requisition.width;
14170
14171   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
14172     y = gdk_screen_get_height (screen) - requisition.height;
14173   else if (tree_y + tree_height < 0) /* isn't really possible ... */
14174     y = 0;
14175   else
14176     y = tree_y + tree_height;
14177
14178   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
14179 }
14180
14181 static void
14182 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
14183                                       GtkMenu  *menu,
14184                                       gpointer  data)
14185 {
14186   GtkTreeView *tree_view = (GtkTreeView *)data;
14187
14188   tree_view->priv->disable_popdown = 1;
14189   g_signal_connect (menu, "hide",
14190                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
14191 }
14192
14193 /* Because we're visible but offscreen, we just set a flag in the preedit
14194  * callback.
14195  */
14196 static void
14197 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
14198                                       GtkTreeView  *tree_view)
14199 {
14200   tree_view->priv->imcontext_changed = 1;
14201   if (tree_view->priv->typeselect_flush_timeout)
14202     {
14203       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14204       tree_view->priv->typeselect_flush_timeout =
14205         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
14206                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
14207                        tree_view);
14208     }
14209
14210 }
14211
14212 static void
14213 gtk_tree_view_search_activate (GtkEntry    *entry,
14214                                GtkTreeView *tree_view)
14215 {
14216   GtkTreePath *path;
14217   GtkRBNode *node;
14218   GtkRBTree *tree;
14219
14220   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
14221                                     tree_view);
14222
14223   /* If we have a row selected and it's the cursor row, we activate
14224    * the row XXX */
14225   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
14226     {
14227       path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
14228
14229       _gtk_tree_view_find_node (tree_view, path, &tree, &node);
14230
14231       if (node && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
14232         gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
14233
14234       gtk_tree_path_free (path);
14235     }
14236 }
14237
14238 static gboolean
14239 gtk_tree_view_real_search_enable_popdown (gpointer data)
14240 {
14241   GtkTreeView *tree_view = (GtkTreeView *)data;
14242
14243   tree_view->priv->disable_popdown = 0;
14244
14245   return FALSE;
14246 }
14247
14248 static void
14249 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
14250                                      gpointer   data)
14251 {
14252   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
14253 }
14254
14255 static gboolean
14256 gtk_tree_view_search_delete_event (GtkWidget *widget,
14257                                    GdkEventAny *event,
14258                                    GtkTreeView *tree_view)
14259 {
14260   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14261
14262   gtk_tree_view_search_dialog_hide (widget, tree_view);
14263
14264   return TRUE;
14265 }
14266
14267 static gboolean
14268 gtk_tree_view_search_button_press_event (GtkWidget *widget,
14269                                          GdkEventButton *event,
14270                                          GtkTreeView *tree_view)
14271 {
14272   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14273
14274   gtk_tree_view_search_dialog_hide (widget, tree_view);
14275
14276   if (event->window == tree_view->priv->bin_window)
14277     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
14278
14279   return TRUE;
14280 }
14281
14282 static gboolean
14283 gtk_tree_view_search_scroll_event (GtkWidget *widget,
14284                                    GdkEventScroll *event,
14285                                    GtkTreeView *tree_view)
14286 {
14287   gboolean retval = FALSE;
14288
14289   if (event->direction == GDK_SCROLL_UP)
14290     {
14291       gtk_tree_view_search_move (widget, tree_view, TRUE);
14292       retval = TRUE;
14293     }
14294   else if (event->direction == GDK_SCROLL_DOWN)
14295     {
14296       gtk_tree_view_search_move (widget, tree_view, FALSE);
14297       retval = TRUE;
14298     }
14299
14300   /* renew the flush timeout */
14301   if (retval && tree_view->priv->typeselect_flush_timeout
14302       && !tree_view->priv->search_custom_entry_set)
14303     {
14304       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14305       tree_view->priv->typeselect_flush_timeout =
14306         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
14307                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
14308                        tree_view);
14309     }
14310
14311   return retval;
14312 }
14313
14314 static gboolean
14315 gtk_tree_view_search_key_press_event (GtkWidget *widget,
14316                                       GdkEventKey *event,
14317                                       GtkTreeView *tree_view)
14318 {
14319   gboolean retval = FALSE;
14320
14321   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14322   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14323
14324   /* close window and cancel the search */
14325   if (!tree_view->priv->search_custom_entry_set
14326       && (event->keyval == GDK_Escape ||
14327           event->keyval == GDK_Tab ||
14328             event->keyval == GDK_KP_Tab ||
14329             event->keyval == GDK_ISO_Left_Tab))
14330     {
14331       gtk_tree_view_search_dialog_hide (widget, tree_view);
14332       return TRUE;
14333     }
14334
14335   /* select previous matching iter */
14336   if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
14337     {
14338       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
14339         gtk_widget_error_bell (widget);
14340
14341       retval = TRUE;
14342     }
14343
14344   if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK))
14345       && (event->keyval == GDK_g || event->keyval == GDK_G))
14346     {
14347       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
14348         gtk_widget_error_bell (widget);
14349
14350       retval = TRUE;
14351     }
14352
14353   /* select next matching iter */
14354   if (event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
14355     {
14356       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
14357         gtk_widget_error_bell (widget);
14358
14359       retval = TRUE;
14360     }
14361
14362   if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == GTK_DEFAULT_ACCEL_MOD_MASK)
14363       && (event->keyval == GDK_g || event->keyval == GDK_G))
14364     {
14365       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
14366         gtk_widget_error_bell (widget);
14367
14368       retval = TRUE;
14369     }
14370
14371   /* renew the flush timeout */
14372   if (retval && tree_view->priv->typeselect_flush_timeout
14373       && !tree_view->priv->search_custom_entry_set)
14374     {
14375       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14376       tree_view->priv->typeselect_flush_timeout =
14377         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
14378                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
14379                        tree_view);
14380     }
14381
14382   return retval;
14383 }
14384
14385 /*  this function returns FALSE if there is a search string but
14386  *  nothing was found, and TRUE otherwise.
14387  */
14388 static gboolean
14389 gtk_tree_view_search_move (GtkWidget   *window,
14390                            GtkTreeView *tree_view,
14391                            gboolean     up)
14392 {
14393   gboolean ret;
14394   gint len;
14395   gint count = 0;
14396   const gchar *text;
14397   GtkTreeIter iter;
14398   GtkTreeModel *model;
14399   GtkTreeSelection *selection;
14400
14401   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
14402
14403   g_return_val_if_fail (text != NULL, FALSE);
14404
14405   len = strlen (text);
14406
14407   if (up && tree_view->priv->selected_iter == 1)
14408     return strlen (text) < 1;
14409
14410   len = strlen (text);
14411
14412   if (len < 1)
14413     return TRUE;
14414
14415   model = gtk_tree_view_get_model (tree_view);
14416   selection = gtk_tree_view_get_selection (tree_view);
14417
14418   /* search */
14419   gtk_tree_selection_unselect_all (selection);
14420   if (!gtk_tree_model_get_iter_first (model, &iter))
14421     return TRUE;
14422
14423   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
14424                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
14425
14426   if (ret)
14427     {
14428       /* found */
14429       tree_view->priv->selected_iter += up?(-1):(1);
14430       return TRUE;
14431     }
14432   else
14433     {
14434       /* return to old iter */
14435       count = 0;
14436       gtk_tree_model_get_iter_first (model, &iter);
14437       gtk_tree_view_search_iter (model, selection,
14438                                  &iter, text,
14439                                  &count, tree_view->priv->selected_iter);
14440       return FALSE;
14441     }
14442 }
14443
14444 static gboolean
14445 gtk_tree_view_search_equal_func (GtkTreeModel *model,
14446                                  gint          column,
14447                                  const gchar  *key,
14448                                  GtkTreeIter  *iter,
14449                                  gpointer      search_data)
14450 {
14451   gboolean retval = TRUE;
14452   const gchar *str;
14453   gchar *normalized_string;
14454   gchar *normalized_key;
14455   gchar *case_normalized_string = NULL;
14456   gchar *case_normalized_key = NULL;
14457   GValue value = {0,};
14458   GValue transformed = {0,};
14459
14460   gtk_tree_model_get_value (model, iter, column, &value);
14461
14462   g_value_init (&transformed, G_TYPE_STRING);
14463
14464   if (!g_value_transform (&value, &transformed))
14465     {
14466       g_value_unset (&value);
14467       return TRUE;
14468     }
14469
14470   g_value_unset (&value);
14471
14472   str = g_value_get_string (&transformed);
14473   if (!str)
14474     {
14475       g_value_unset (&transformed);
14476       return TRUE;
14477     }
14478
14479   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
14480   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
14481
14482   if (normalized_string && normalized_key)
14483     {
14484       case_normalized_string = g_utf8_casefold (normalized_string, -1);
14485       case_normalized_key = g_utf8_casefold (normalized_key, -1);
14486
14487       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
14488         retval = FALSE;
14489     }
14490
14491   g_value_unset (&transformed);
14492   g_free (normalized_key);
14493   g_free (normalized_string);
14494   g_free (case_normalized_key);
14495   g_free (case_normalized_string);
14496
14497   return retval;
14498 }
14499
14500 static gboolean
14501 gtk_tree_view_search_iter (GtkTreeModel     *model,
14502                            GtkTreeSelection *selection,
14503                            GtkTreeIter      *iter,
14504                            const gchar      *text,
14505                            gint             *count,
14506                            gint              n)
14507 {
14508   GtkRBTree *tree = NULL;
14509   GtkRBNode *node = NULL;
14510   GtkTreePath *path;
14511
14512   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
14513
14514   path = gtk_tree_model_get_path (model, iter);
14515   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
14516
14517   do
14518     {
14519       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
14520         {
14521           (*count)++;
14522           if (*count == n)
14523             {
14524               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
14525                                             TRUE, 0.5, 0.0);
14526               gtk_tree_selection_select_iter (selection, iter);
14527               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
14528
14529               if (path)
14530                 gtk_tree_path_free (path);
14531
14532               return TRUE;
14533             }
14534         }
14535
14536       if (node->children)
14537         {
14538           gboolean has_child;
14539           GtkTreeIter tmp;
14540
14541           tree = node->children;
14542           node = tree->root;
14543
14544           while (node->left != tree->nil)
14545             node = node->left;
14546
14547           tmp = *iter;
14548           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
14549           gtk_tree_path_down (path);
14550
14551           /* sanity check */
14552           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
14553         }
14554       else
14555         {
14556           gboolean done = FALSE;
14557
14558           do
14559             {
14560               node = _gtk_rbtree_next (tree, node);
14561
14562               if (node)
14563                 {
14564                   gboolean has_next;
14565
14566                   has_next = gtk_tree_model_iter_next (model, iter);
14567
14568                   done = TRUE;
14569                   gtk_tree_path_next (path);
14570
14571                   /* sanity check */
14572                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
14573                 }
14574               else
14575                 {
14576                   gboolean has_parent;
14577                   GtkTreeIter tmp_iter = *iter;
14578
14579                   node = tree->parent_node;
14580                   tree = tree->parent_tree;
14581
14582                   if (!tree)
14583                     {
14584                       if (path)
14585                         gtk_tree_path_free (path);
14586
14587                       /* we've run out of tree, done with this func */
14588                       return FALSE;
14589                     }
14590
14591                   has_parent = gtk_tree_model_iter_parent (model,
14592                                                            iter,
14593                                                            &tmp_iter);
14594                   gtk_tree_path_up (path);
14595
14596                   /* sanity check */
14597                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
14598                 }
14599             }
14600           while (!done);
14601         }
14602     }
14603   while (1);
14604
14605   return FALSE;
14606 }
14607
14608 static void
14609 gtk_tree_view_search_init (GtkWidget   *entry,
14610                            GtkTreeView *tree_view)
14611 {
14612   gint ret;
14613   gint count = 0;
14614   const gchar *text;
14615   GtkTreeIter iter;
14616   GtkTreeModel *model;
14617   GtkTreeSelection *selection;
14618
14619   g_return_if_fail (GTK_IS_ENTRY (entry));
14620   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14621
14622   text = gtk_entry_get_text (GTK_ENTRY (entry));
14623
14624   model = gtk_tree_view_get_model (tree_view);
14625   selection = gtk_tree_view_get_selection (tree_view);
14626
14627   /* search */
14628   gtk_tree_selection_unselect_all (selection);
14629   if (tree_view->priv->typeselect_flush_timeout
14630       && !tree_view->priv->search_custom_entry_set)
14631     {
14632       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14633       tree_view->priv->typeselect_flush_timeout =
14634         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
14635                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
14636                        tree_view);
14637     }
14638
14639   if (*text == '\0')
14640     return;
14641
14642   if (!gtk_tree_model_get_iter_first (model, &iter))
14643     return;
14644
14645   ret = gtk_tree_view_search_iter (model, selection,
14646                                    &iter, text,
14647                                    &count, 1);
14648
14649   if (ret)
14650     tree_view->priv->selected_iter = 1;
14651 }
14652
14653 static void
14654 gtk_tree_view_remove_widget (GtkCellEditable *cell_editable,
14655                              GtkTreeView     *tree_view)
14656 {
14657   if (tree_view->priv->edited_column == NULL)
14658     return;
14659
14660   _gtk_tree_view_column_stop_editing (tree_view->priv->edited_column);
14661   tree_view->priv->edited_column = NULL;
14662
14663   if (GTK_WIDGET_HAS_FOCUS (cell_editable))
14664     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
14665
14666   g_signal_handlers_disconnect_by_func (cell_editable,
14667                                         gtk_tree_view_remove_widget,
14668                                         tree_view);
14669
14670   gtk_container_remove (GTK_CONTAINER (tree_view),
14671                         GTK_WIDGET (cell_editable));
14672
14673   /* FIXME should only redraw a single node */
14674   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
14675 }
14676
14677 static gboolean
14678 gtk_tree_view_start_editing (GtkTreeView *tree_view,
14679                              GtkTreePath *cursor_path)
14680 {
14681   GtkTreeIter iter;
14682   GdkRectangle background_area;
14683   GdkRectangle cell_area;
14684   GtkCellEditable *editable_widget = NULL;
14685   gchar *path_string;
14686   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
14687   gint retval = FALSE;
14688   GtkRBTree *cursor_tree;
14689   GtkRBNode *cursor_node;
14690
14691   g_assert (tree_view->priv->focus_column);
14692
14693   if (! GTK_WIDGET_REALIZED (tree_view))
14694     return FALSE;
14695
14696   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
14697       cursor_node == NULL)
14698     return FALSE;
14699
14700   path_string = gtk_tree_path_to_string (cursor_path);
14701   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
14702
14703   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
14704
14705   gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
14706                                            tree_view->priv->model,
14707                                            &iter,
14708                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
14709                                            cursor_node->children?TRUE:FALSE);
14710   gtk_tree_view_get_background_area (tree_view,
14711                                      cursor_path,
14712                                      tree_view->priv->focus_column,
14713                                      &background_area);
14714   gtk_tree_view_get_cell_area (tree_view,
14715                                cursor_path,
14716                                tree_view->priv->focus_column,
14717                                &cell_area);
14718
14719   if (_gtk_tree_view_column_cell_event (tree_view->priv->focus_column,
14720                                         &editable_widget,
14721                                         NULL,
14722                                         path_string,
14723                                         &background_area,
14724                                         &cell_area,
14725                                         flags))
14726     {
14727       retval = TRUE;
14728       if (editable_widget != NULL)
14729         {
14730           gint left, right;
14731           GdkRectangle area;
14732           GtkCellRenderer *cell;
14733
14734           area = cell_area;
14735           cell = _gtk_tree_view_column_get_edited_cell (tree_view->priv->focus_column);
14736
14737           _gtk_tree_view_column_get_neighbor_sizes (tree_view->priv->focus_column, cell, &left, &right);
14738
14739           area.x += left;
14740           area.width -= right + left;
14741
14742           gtk_tree_view_real_start_editing (tree_view,
14743                                             tree_view->priv->focus_column,
14744                                             cursor_path,
14745                                             editable_widget,
14746                                             &area,
14747                                             NULL,
14748                                             flags);
14749         }
14750
14751     }
14752   g_free (path_string);
14753   return retval;
14754 }
14755
14756 static void
14757 gtk_tree_view_real_start_editing (GtkTreeView       *tree_view,
14758                                   GtkTreeViewColumn *column,
14759                                   GtkTreePath       *path,
14760                                   GtkCellEditable   *cell_editable,
14761                                   GdkRectangle      *cell_area,
14762                                   GdkEvent          *event,
14763                                   guint              flags)
14764 {
14765   gint pre_val = tree_view->priv->vadjustment->value;
14766   GtkRequisition requisition;
14767
14768   tree_view->priv->edited_column = column;
14769   _gtk_tree_view_column_start_editing (column, GTK_CELL_EDITABLE (cell_editable));
14770
14771   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
14772   cell_area->y += pre_val - (int)tree_view->priv->vadjustment->value;
14773
14774   gtk_widget_size_request (GTK_WIDGET (cell_editable), &requisition);
14775
14776   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
14777
14778   if (requisition.height < cell_area->height)
14779     {
14780       gint diff = cell_area->height - requisition.height;
14781       gtk_tree_view_put (tree_view,
14782                          GTK_WIDGET (cell_editable),
14783                          cell_area->x, cell_area->y + diff/2,
14784                          cell_area->width, requisition.height);
14785     }
14786   else
14787     {
14788       gtk_tree_view_put (tree_view,
14789                          GTK_WIDGET (cell_editable),
14790                          cell_area->x, cell_area->y,
14791                          cell_area->width, cell_area->height);
14792     }
14793
14794   gtk_cell_editable_start_editing (GTK_CELL_EDITABLE (cell_editable),
14795                                    (GdkEvent *)event);
14796
14797   gtk_widget_grab_focus (GTK_WIDGET (cell_editable));
14798   g_signal_connect (cell_editable, "remove-widget",
14799                     G_CALLBACK (gtk_tree_view_remove_widget), tree_view);
14800 }
14801
14802 static void
14803 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
14804                             gboolean     cancel_editing)
14805 {
14806   GtkTreeViewColumn *column;
14807   GtkCellRenderer *cell;
14808
14809   if (tree_view->priv->edited_column == NULL)
14810     return;
14811
14812   /*
14813    * This is very evil. We need to do this, because
14814    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
14815    * later on. If gtk_tree_view_row_changed notices
14816    * tree_view->priv->edited_column != NULL, it'll call
14817    * gtk_tree_view_stop_editing again. Bad things will happen then.
14818    *
14819    * Please read that again if you intend to modify anything here.
14820    */
14821
14822   column = tree_view->priv->edited_column;
14823   tree_view->priv->edited_column = NULL;
14824
14825   cell = _gtk_tree_view_column_get_edited_cell (column);
14826   gtk_cell_renderer_stop_editing (cell, cancel_editing);
14827
14828   if (!cancel_editing)
14829     gtk_cell_editable_editing_done (column->editable_widget);
14830
14831   tree_view->priv->edited_column = column;
14832
14833   gtk_cell_editable_remove_widget (column->editable_widget);
14834 }
14835
14836
14837 /**
14838  * gtk_tree_view_set_hover_selection:
14839  * @tree_view: a #GtkTreeView
14840  * @hover: %TRUE to enable hover selection mode
14841  *
14842  * Enables of disables the hover selection mode of @tree_view.
14843  * Hover selection makes the selected row follow the pointer.
14844  * Currently, this works only for the selection modes
14845  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
14846  *
14847  * Since: 2.6
14848  **/
14849 void
14850 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
14851                                    gboolean     hover)
14852 {
14853   hover = hover != FALSE;
14854
14855   if (hover != tree_view->priv->hover_selection)
14856     {
14857       tree_view->priv->hover_selection = hover;
14858
14859       g_object_notify (G_OBJECT (tree_view), "hover-selection");
14860     }
14861 }
14862
14863 /**
14864  * gtk_tree_view_get_hover_selection:
14865  * @tree_view: a #GtkTreeView
14866  *
14867  * Returns whether hover selection mode is turned on for @tree_view.
14868  *
14869  * Return value: %TRUE if @tree_view is in hover selection mode
14870  *
14871  * Since: 2.6
14872  **/
14873 gboolean
14874 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
14875 {
14876   return tree_view->priv->hover_selection;
14877 }
14878
14879 /**
14880  * gtk_tree_view_set_hover_expand:
14881  * @tree_view: a #GtkTreeView
14882  * @expand: %TRUE to enable hover selection mode
14883  *
14884  * Enables of disables the hover expansion mode of @tree_view.
14885  * Hover expansion makes rows expand or collapse if the pointer
14886  * moves over them.
14887  *
14888  * Since: 2.6
14889  **/
14890 void
14891 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
14892                                 gboolean     expand)
14893 {
14894   expand = expand != FALSE;
14895
14896   if (expand != tree_view->priv->hover_expand)
14897     {
14898       tree_view->priv->hover_expand = expand;
14899
14900       g_object_notify (G_OBJECT (tree_view), "hover-expand");
14901     }
14902 }
14903
14904 /**
14905  * gtk_tree_view_get_hover_expand:
14906  * @tree_view: a #GtkTreeView
14907  *
14908  * Returns whether hover expansion mode is turned on for @tree_view.
14909  *
14910  * Return value: %TRUE if @tree_view is in hover expansion mode
14911  *
14912  * Since: 2.6
14913  **/
14914 gboolean
14915 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
14916 {
14917   return tree_view->priv->hover_expand;
14918 }
14919
14920 /**
14921  * gtk_tree_view_set_rubber_banding:
14922  * @tree_view: a #GtkTreeView
14923  * @enable: %TRUE to enable rubber banding
14924  *
14925  * Enables or disables rubber banding in @tree_view.  If the selection mode
14926  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
14927  * multiple rows by dragging the mouse.
14928  *
14929  * Since: 2.10
14930  **/
14931 void
14932 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
14933                                   gboolean     enable)
14934 {
14935   enable = enable != FALSE;
14936
14937   if (enable != tree_view->priv->rubber_banding_enable)
14938     {
14939       tree_view->priv->rubber_banding_enable = enable;
14940
14941       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
14942     }
14943 }
14944
14945 /**
14946  * gtk_tree_view_get_rubber_banding:
14947  * @tree_view: a #GtkTreeView
14948  *
14949  * Returns whether rubber banding is turned on for @tree_view.  If the
14950  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
14951  * user to select multiple rows by dragging the mouse.
14952  *
14953  * Return value: %TRUE if rubber banding in @tree_view is enabled.
14954  *
14955  * Since: 2.10
14956  **/
14957 gboolean
14958 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
14959 {
14960   return tree_view->priv->rubber_banding_enable;
14961 }
14962
14963 /**
14964  * gtk_tree_view_is_rubber_banding_active:
14965  * @tree_view: a #GtkTreeView
14966  *
14967  * Returns whether a rubber banding operation is currently being done
14968  * in @tree_view.
14969  *
14970  * Return value: %TRUE if a rubber banding operation is currently being
14971  * done in @tree_view.
14972  *
14973  * Since: 2.12
14974  **/
14975 gboolean
14976 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
14977 {
14978   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14979
14980   if (tree_view->priv->rubber_banding_enable
14981       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
14982     return TRUE;
14983
14984   return FALSE;
14985 }
14986
14987 /**
14988  * gtk_tree_view_get_row_separator_func:
14989  * @tree_view: a #GtkTreeView
14990  *
14991  * Returns the current row separator function.
14992  *
14993  * Return value: the current row separator function.
14994  *
14995  * Since: 2.6
14996  **/
14997 GtkTreeViewRowSeparatorFunc
14998 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
14999 {
15000   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15001
15002   return tree_view->priv->row_separator_func;
15003 }
15004
15005 /**
15006  * gtk_tree_view_set_row_separator_func:
15007  * @tree_view: a #GtkTreeView
15008  * @func: a #GtkTreeViewRowSeparatorFunc
15009  * @data: user data to pass to @func, or %NULL
15010  * @destroy: destroy notifier for @data, or %NULL
15011  *
15012  * Sets the row separator function, which is used to determine
15013  * whether a row should be drawn as a separator. If the row separator
15014  * function is %NULL, no separators are drawn. This is the default value.
15015  *
15016  * Since: 2.6
15017  **/
15018 void
15019 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15020                                       GtkTreeViewRowSeparatorFunc  func,
15021                                       gpointer                     data,
15022                                       GDestroyNotify               destroy)
15023 {
15024   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15025
15026   if (tree_view->priv->row_separator_destroy)
15027     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15028
15029   tree_view->priv->row_separator_func = func;
15030   tree_view->priv->row_separator_data = data;
15031   tree_view->priv->row_separator_destroy = destroy;
15032
15033   /* Have the tree recalculate heights */
15034   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15035   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15036 }
15037
15038
15039 static void
15040 gtk_tree_view_grab_notify (GtkWidget *widget,
15041                            gboolean   was_grabbed)
15042 {
15043   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15044
15045   tree_view->priv->in_grab = !was_grabbed;
15046
15047   if (!was_grabbed)
15048     {
15049       tree_view->priv->pressed_button = -1;
15050
15051       if (tree_view->priv->rubber_band_status)
15052         gtk_tree_view_stop_rubber_band (tree_view);
15053     }
15054 }
15055
15056 static void
15057 gtk_tree_view_state_changed (GtkWidget      *widget,
15058                              GtkStateType    previous_state)
15059 {
15060   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15061
15062   if (GTK_WIDGET_REALIZED (widget))
15063     {
15064       gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
15065       gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
15066     }
15067
15068   gtk_widget_queue_draw (widget);
15069 }
15070
15071 /**
15072  * gtk_tree_view_get_grid_lines:
15073  * @tree_view: a #GtkTreeView
15074  *
15075  * Returns which grid lines are enabled in @tree_view.
15076  *
15077  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15078  * are enabled.
15079  *
15080  * Since: 2.10
15081  */
15082 GtkTreeViewGridLines
15083 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15084 {
15085   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15086
15087   return tree_view->priv->grid_lines;
15088 }
15089
15090 /**
15091  * gtk_tree_view_set_grid_lines:
15092  * @tree_view: a #GtkTreeView
15093  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15094  * enable.
15095  *
15096  * Sets which grid lines to draw in @tree_view.
15097  *
15098  * Since: 2.10
15099  */
15100 void
15101 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15102                               GtkTreeViewGridLines   grid_lines)
15103 {
15104   GtkTreeViewPrivate *priv;
15105   GtkWidget *widget;
15106   GtkTreeViewGridLines old_grid_lines;
15107
15108   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15109
15110   priv = tree_view->priv;
15111   widget = GTK_WIDGET (tree_view);
15112
15113   old_grid_lines = priv->grid_lines;
15114   priv->grid_lines = grid_lines;
15115
15116   if (GTK_WIDGET_REALIZED (widget))
15117     {
15118       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15119           priv->grid_line_gc)
15120         {
15121           g_object_unref (priv->grid_line_gc);
15122           priv->grid_line_gc = NULL;
15123         }
15124
15125       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15126           !priv->grid_line_gc)
15127         {
15128           gint line_width;
15129           gint8 *dash_list;
15130
15131           gtk_widget_style_get (widget,
15132                                 "grid-line-width", &line_width,
15133                                 "grid-line-pattern", (gchar *)&dash_list,
15134                                 NULL);
15135
15136           priv->grid_line_gc = gdk_gc_new (widget->window);
15137           gdk_gc_copy (priv->grid_line_gc, widget->style->black_gc);
15138
15139           gdk_gc_set_line_attributes (priv->grid_line_gc, line_width,
15140                                       GDK_LINE_ON_OFF_DASH,
15141                                       GDK_CAP_BUTT, GDK_JOIN_MITER);
15142           gdk_gc_set_dashes (priv->grid_line_gc, 0, dash_list, 2);
15143
15144           g_free (dash_list);
15145         }
15146     }
15147
15148   if (old_grid_lines != grid_lines)
15149     {
15150       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15151
15152       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
15153     }
15154 }
15155
15156 /**
15157  * gtk_tree_view_get_enable_tree_lines:
15158  * @tree_view: a #GtkTreeView.
15159  *
15160  * Returns whether or not tree lines are drawn in @tree_view.
15161  *
15162  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
15163  * otherwise.
15164  *
15165  * Since: 2.10
15166  */
15167 gboolean
15168 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
15169 {
15170   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15171
15172   return tree_view->priv->tree_lines_enabled;
15173 }
15174
15175 /**
15176  * gtk_tree_view_set_enable_tree_lines:
15177  * @tree_view: a #GtkTreeView
15178  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
15179  *
15180  * Sets whether to draw lines interconnecting the expanders in @tree_view.
15181  * This does not have any visible effects for lists.
15182  *
15183  * Since: 2.10
15184  */
15185 void
15186 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
15187                                      gboolean     enabled)
15188 {
15189   GtkTreeViewPrivate *priv;
15190   GtkWidget *widget;
15191   gboolean was_enabled;
15192
15193   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15194
15195   enabled = enabled != FALSE;
15196
15197   priv = tree_view->priv;
15198   widget = GTK_WIDGET (tree_view);
15199
15200   was_enabled = priv->tree_lines_enabled;
15201
15202   priv->tree_lines_enabled = enabled;
15203
15204   if (GTK_WIDGET_REALIZED (widget))
15205     {
15206       if (!enabled && priv->tree_line_gc)
15207         {
15208           g_object_unref (priv->tree_line_gc);
15209           priv->tree_line_gc = NULL;
15210         }
15211
15212       if (enabled && !priv->tree_line_gc)
15213         {
15214           gint line_width;
15215           gint8 *dash_list;
15216           gtk_widget_style_get (widget,
15217                                 "tree-line-width", &line_width,
15218                                 "tree-line-pattern", (gchar *)&dash_list,
15219                                 NULL);
15220
15221           priv->tree_line_gc = gdk_gc_new (widget->window);
15222           gdk_gc_copy (priv->tree_line_gc, widget->style->black_gc);
15223
15224           gdk_gc_set_line_attributes (priv->tree_line_gc, line_width,
15225                                       GDK_LINE_ON_OFF_DASH,
15226                                       GDK_CAP_BUTT, GDK_JOIN_MITER);
15227           gdk_gc_set_dashes (priv->tree_line_gc, 0, dash_list, 2);
15228
15229           g_free (dash_list);
15230         }
15231     }
15232
15233   if (was_enabled != enabled)
15234     {
15235       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15236
15237       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
15238     }
15239 }
15240
15241
15242 /**
15243  * gtk_tree_view_set_show_expanders:
15244  * @tree_view: a #GtkTreeView
15245  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
15246  *
15247  * Sets whether to draw and enable expanders and indent child rows in
15248  * @tree_view.  When disabled there will be no expanders visible in trees
15249  * and there will be no way to expand and collapse rows by default.  Also
15250  * note that hiding the expanders will disable the default indentation.  You
15251  * can set a custom indentation in this case using
15252  * gtk_tree_view_set_level_indentation().
15253  * This does not have any visible effects for lists.
15254  *
15255  * Since: 2.12
15256  */
15257 void
15258 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
15259                                   gboolean     enabled)
15260 {
15261   gboolean was_enabled;
15262
15263   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15264
15265   enabled = enabled != FALSE;
15266   was_enabled = GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15267
15268   if (enabled)
15269     GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15270   else
15271     GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15272
15273   if (enabled != was_enabled)
15274     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15275 }
15276
15277 /**
15278  * gtk_tree_view_get_show_expanders:
15279  * @tree_view: a #GtkTreeView.
15280  *
15281  * Returns whether or not expanders are drawn in @tree_view.
15282  *
15283  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
15284  * otherwise.
15285  *
15286  * Since: 2.12
15287  */
15288 gboolean
15289 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
15290 {
15291   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15292
15293   return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15294 }
15295
15296 /**
15297  * gtk_tree_view_set_level_indentation:
15298  * @tree_view: a #GtkTreeView
15299  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
15300  *
15301  * Sets the amount of extra indentation for child levels to use in @tree_view
15302  * in addition to the default indentation.  The value should be specified in
15303  * pixels, a value of 0 disables this feature and in this case only the default
15304  * indentation will be used.
15305  * This does not have any visible effects for lists.
15306  *
15307  * Since: 2.12
15308  */
15309 void
15310 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
15311                                      gint         indentation)
15312 {
15313   tree_view->priv->level_indentation = indentation;
15314
15315   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15316 }
15317
15318 /**
15319  * gtk_tree_view_get_level_indentation:
15320  * @tree_view: a #GtkTreeView.
15321  *
15322  * Returns the amount, in pixels, of extra indentation for child levels
15323  * in @tree_view.
15324  *
15325  * Return value: the amount of extra indentation for child levels in
15326  * @tree_view.  A return value of 0 means that this feature is disabled.
15327  *
15328  * Since: 2.12
15329  */
15330 gint
15331 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
15332 {
15333   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15334
15335   return tree_view->priv->level_indentation;
15336 }
15337
15338 /**
15339  * gtk_tree_view_set_tooltip_row:
15340  * @tree_view: a #GtkTreeView
15341  * @tooltip: a #GtkTooltip
15342  * @path: a #GtkTreePath
15343  *
15344  * Sets the tip area of @tooltip to be the area covered by the row at @path.
15345  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
15346  * See also gtk_tooltip_set_tip_area().
15347  *
15348  * Since: 2.12
15349  */
15350 void
15351 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
15352                                GtkTooltip  *tooltip,
15353                                GtkTreePath *path)
15354 {
15355   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15356   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
15357
15358   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
15359 }
15360
15361 /**
15362  * gtk_tree_view_set_tooltip_cell:
15363  * @tree_view: a #GtkTreeView
15364  * @tooltip: a #GtkTooltip
15365  * @path: a #GtkTreePath or %NULL
15366  * @column: a #GtkTreeViewColumn or %NULL
15367  * @cell: a #GtkCellRenderer or %NULL
15368  *
15369  * Sets the tip area of @tooltip to the area @path, @column and @cell have
15370  * in common.  For example if @path is %NULL and @column is set, the tip
15371  * area will be set to the full area covered by @column.  See also
15372  * gtk_tooltip_set_tip_area().
15373  *
15374  * Note that if @path is not specified and @cell is set and part of a column
15375  * containing the expander, the tooltip might not show and hide at the correct
15376  * position.  In such cases @path must be set to the current node under the
15377  * mouse cursor for this function to operate correctly.
15378  *
15379  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
15380  *
15381  * Since: 2.12
15382  */
15383 void
15384 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
15385                                 GtkTooltip        *tooltip,
15386                                 GtkTreePath       *path,
15387                                 GtkTreeViewColumn *column,
15388                                 GtkCellRenderer   *cell)
15389 {
15390   GdkRectangle rect;
15391
15392   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15393   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
15394   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
15395   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
15396
15397   /* Determine x values. */
15398   if (column && cell)
15399     {
15400       GdkRectangle tmp;
15401       gint start, width;
15402
15403       /* We always pass in path here, whether it is NULL or not.
15404        * For cells in expander columns path must be specified so that
15405        * we can correctly account for the indentation.  This also means
15406        * that the tooltip is constrained vertically by the "Determine y
15407        * values" code below; this is not a real problem since cells actually
15408        * don't stretch vertically in constrast to columns.
15409        */
15410       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
15411       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
15412
15413       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
15414                                                          tmp.x + start, 0,
15415                                                          &rect.x, NULL);
15416       rect.width = width;
15417     }
15418   else if (column)
15419     {
15420       GdkRectangle tmp;
15421
15422       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
15423       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
15424                                                          tmp.x, 0,
15425                                                          &rect.x, NULL);
15426       rect.width = tmp.width;
15427     }
15428   else
15429     {
15430       rect.x = 0;
15431       rect.width = GTK_WIDGET (tree_view)->allocation.width;
15432     }
15433
15434   /* Determine y values. */
15435   if (path)
15436     {
15437       GdkRectangle tmp;
15438
15439       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
15440       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
15441                                                          0, tmp.y,
15442                                                          NULL, &rect.y);
15443       rect.height = tmp.height;
15444     }
15445   else
15446     {
15447       rect.y = 0;
15448       rect.height = tree_view->priv->vadjustment->page_size;
15449     }
15450
15451   gtk_tooltip_set_tip_area (tooltip, &rect);
15452 }
15453
15454 /**
15455  * gtk_tree_view_get_tooltip_context:
15456  * @tree_view: a #GtkTreeView
15457  * @x: the x coordinate (relative to widget coordinates)
15458  * @y: the y coordinate (relative to widget coordinates)
15459  * @keyboard_tip: whether this is a keyboard tooltip or not
15460  * @model: a pointer to receive a #GtkTreeModel or %NULL
15461  * @path: a pointer to receive a #GtkTreePath or %NULL
15462  * @iter: a pointer to receive a #GtkTreeIter or %NULL
15463  *
15464  * This function is supposed to be used in a #GtkWidget::query-tooltip
15465  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
15466  * which are received in the signal handler, should be passed to this
15467  * function without modification.
15468  *
15469  * The return value indicates whether there is a tree view row at the given
15470  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
15471  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
15472  * @model, @path and @iter which have been provided will be set to point to
15473  * that row and the corresponding model.  @x and @y will always be converted
15474  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
15475  *
15476  * Return value: whether or not the given tooltip context points to a row.
15477  *
15478  * Since: 2.12
15479  */
15480 gboolean
15481 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
15482                                    gint          *x,
15483                                    gint          *y,
15484                                    gboolean       keyboard_tip,
15485                                    GtkTreeModel **model,
15486                                    GtkTreePath  **path,
15487                                    GtkTreeIter   *iter)
15488 {
15489   GtkTreePath *tmppath = NULL;
15490
15491   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15492   g_return_val_if_fail (x != NULL, FALSE);
15493   g_return_val_if_fail (y != NULL, FALSE);
15494
15495   if (keyboard_tip)
15496     {
15497       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
15498
15499       if (!tmppath)
15500         return FALSE;
15501     }
15502   else
15503     {
15504       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
15505                                                          x, y);
15506
15507       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
15508                                           &tmppath, NULL, NULL, NULL))
15509         return FALSE;
15510     }
15511
15512   if (model)
15513     *model = gtk_tree_view_get_model (tree_view);
15514
15515   if (iter)
15516     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
15517                              iter, tmppath);
15518
15519   if (path)
15520     *path = tmppath;
15521   else
15522     gtk_tree_path_free (tmppath);
15523
15524   return TRUE;
15525 }
15526
15527 static gboolean
15528 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
15529                                     gint        x,
15530                                     gint        y,
15531                                     gboolean    keyboard_tip,
15532                                     GtkTooltip *tooltip,
15533                                     gpointer    data)
15534 {
15535   GValue value = { 0, };
15536   GValue transformed = { 0, };
15537   GtkTreeIter iter;
15538   GtkTreePath *path;
15539   GtkTreeModel *model;
15540   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15541
15542   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
15543                                           &x, &y,
15544                                           keyboard_tip,
15545                                           &model, &path, &iter))
15546     return FALSE;
15547
15548   gtk_tree_model_get_value (model, &iter,
15549                             tree_view->priv->tooltip_column, &value);
15550
15551   g_value_init (&transformed, G_TYPE_STRING);
15552
15553   if (!g_value_transform (&value, &transformed))
15554     {
15555       g_value_unset (&value);
15556       gtk_tree_path_free (path);
15557
15558       return FALSE;
15559     }
15560
15561   g_value_unset (&value);
15562
15563   if (!g_value_get_string (&transformed))
15564     {
15565       g_value_unset (&transformed);
15566       gtk_tree_path_free (path);
15567
15568       return FALSE;
15569     }
15570
15571   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
15572   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
15573
15574   gtk_tree_path_free (path);
15575   g_value_unset (&transformed);
15576
15577   return TRUE;
15578 }
15579
15580 /**
15581  * gtk_tree_view_set_tooltip_column:
15582  * @tree_view: a #GtkTreeView
15583  * @column: an integer, which is a valid column number for @tree_view's model
15584  *
15585  * If you only plan to have simple (text-only) tooltips on full rows, you
15586  * can use this function to have #GtkTreeView handle these automatically
15587  * for you. @column should be set to the column in @tree_view's model
15588  * containing the tooltip texts, or -1 to disable this feature.
15589  *
15590  * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
15591  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
15592  *
15593  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
15594  * so &amp;, &lt;, etc have to be escaped in the text.
15595  *
15596  * Since: 2.12
15597  */
15598 void
15599 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
15600                                   gint         column)
15601 {
15602   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15603
15604   if (column == tree_view->priv->tooltip_column)
15605     return;
15606
15607   if (column == -1)
15608     {
15609       g_signal_handlers_disconnect_by_func (tree_view,
15610                                             gtk_tree_view_set_tooltip_query_cb,
15611                                             NULL);
15612       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
15613     }
15614   else
15615     {
15616       if (tree_view->priv->tooltip_column == -1)
15617         {
15618           g_signal_connect (tree_view, "query-tooltip",
15619                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
15620           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
15621         }
15622     }
15623
15624   tree_view->priv->tooltip_column = column;
15625   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
15626 }
15627
15628 /**
15629  * gtk_tree_view_get_tooltip_column:
15630  * @tree_view: a #GtkTreeView
15631  *
15632  * Returns the column of @tree_view's model which is being used for
15633  * displaying tooltips on @tree_view's rows.
15634  *
15635  * Return value: the index of the tooltip column that is currently being
15636  * used, or -1 if this is disabled.
15637  *
15638  * Since: 2.12
15639  */
15640 gint
15641 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
15642 {
15643   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15644
15645   return tree_view->priv->tooltip_column;
15646 }
15647
15648 static void
15649 gtk_tree_view_extended_layout_get_desired_size (GtkExtendedLayout *layout,
15650                                                 GtkRequisition    *minimal_size,
15651                                                 GtkRequisition    *desired_size)
15652 {
15653   GtkTreeView *tree_view;
15654   gint natural_width = 0;
15655   GList *column_iter;
15656   GtkRequisition requisition;
15657
15658   tree_view = GTK_TREE_VIEW (layout);
15659
15660   gtk_widget_size_request (GTK_WIDGET (layout), &requisition);
15661
15662   for (column_iter = tree_view->priv->columns; column_iter; column_iter = column_iter->next)
15663     {
15664       GtkTreeViewColumn *column = column_iter->data;
15665
15666       if (!column->visible)
15667         continue;
15668
15669       natural_width += gtk_tree_view_get_real_natural_width_from_column (tree_view, column);
15670     }
15671
15672   if (minimal_size)
15673     *minimal_size = requisition;
15674
15675   if (desired_size)
15676     {
15677       desired_size->height = requisition.height;
15678       desired_size->width = natural_width;
15679     }
15680 }
15681
15682 static void
15683 gtk_tree_view_extended_layout_init (GtkExtendedLayoutIface *iface)
15684 {
15685   iface->get_desired_size = gtk_tree_view_extended_layout_get_desired_size;
15686 }
15687
15688
15689 #define __GTK_TREE_VIEW_C__
15690 #include "gtkaliasdef.c"