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, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18
  19 #include "config.h"
  20
  21 #include <math.h>
  22 #include <string.h>
  23
  24 #include "gtktreeview.h"
  25 #include "gtkrbtree.h"
  26 #include "gtktreednd.h"
  27 #include "gtktreeprivate.h"
  28 #include "gtkcellrenderer.h"
  29 #include "gtkmarshalers.h"
  30 #include "gtkbuildable.h"
  31 #include "gtkbutton.h"
  32 #include "gtklabel.h"
  33 #include "gtkbox.h"
  34 #include "gtkarrow.h"
  35 #include "gtkintl.h"
  36 #include "gtkbindings.h"
  37 #include "gtkcontainer.h"
  38 #include "gtkentry.h"
  39 #include "gtkframe.h"
  40 #include "gtkmain.h"
  41 #include "gtktreemodelsort.h"
  42 #include "gtktooltip.h"
  43 #include "gtkscrollable.h"
  44 #include "gtkcelllayout.h"
  45 #include "gtkprivate.h"
  46 #include "gtkwidgetprivate.h"
  47 #include "gtkentryprivate.h"
  48 #include "gtkstylecontextprivate.h"
  49 #include "gtktypebuiltins.h"
  50 #include "gtkmain.h"
  51 #include "a11y/gtktreeviewaccessible.h"
  52
  53
  54 /**
  55  * SECTION:gtktreeview
  56  * @Short_description: A widget for displaying both trees and lists
  57  * @Title: GtkTreeView
  58  * @See_also: #GtkTreeViewColumn, #GtkTreeSelection, #GtkTreeDnd, #GtkTreeMode,
  59  *   #GtkTreeSortable, #GtkTreeModelSort, #GtkListStore, #GtkTreeStore,
  60  *   #GtkCellRenderer, #GtkCellEditable, #GtkCellRendererPixbuf,
  61  *   #GtkCellRendererText, #GtkCellRendererToggle
  62  *
  63  * Widget that displays any object that implements the #GtkTreeModel interface.
  64  *
  65  * Please refer to the <link linkend="TreeWidget">tree widget conceptual
  66  * overview</link> for an overview of all the objects and data types related
  67  * to the tree widget and how they work together.
  68  *
  69  * Several different coordinate systems are exposed in the GtkTreeView API.
  70  * These are:
  71  *
  72  * <inlinegraphic fileref="tree-view-coordinates.png" format="PNG"></inlinegraphic>
  73  * <variablelist><title>Coordinate systems in GtkTreeView API</title>
  74  * <varlistentry><term>Widget coordinates</term>
  75  * <listitem>
  76  * <para>
  77  * Coordinates relative to the widget (usually <literal>widget->window</literal>).
  78  * </para>
  79  * </listitem>
  80  * </varlistentry>
  81  * <varlistentry><term>Bin window coordinates</term>
  82  * <listitem>
  83  * <para>
  84  * Coordinates relative to the window that GtkTreeView renders to.
  85  * </para>
  86  * </listitem>
  87  * </varlistentry>
  88  * <varlistentry><term>Tree coordinates</term>
  89  * <listitem>
  90  * <para>
  91  * Coordinates relative to the entire scrollable area of GtkTreeView. These
  92  * coordinates start at (0, 0) for row 0 of the tree.
  93  * </para>
  94  * </listitem>
  95  * </varlistentry>
  96  * </variablelist>
  97  *
  98  * Several functions are available for converting between the different
  99  * coordinate systems.  The most common translations are between widget and bin
 100  * window coordinates and between bin window and tree coordinates. For the
 101  * former you can use gtk_tree_view_convert_widget_to_bin_window_coords()
 102  * (and vice versa), for the latter gtk_tree_view_convert_bin_window_to_tree_coords()
 103  * (and vice versa).
 104  *
 105  * <refsect2 id="GtkTreeView-BUILDER-UI">
 106  * <title>GtkTreeView as GtkBuildable</title>
 107  * The GtkTreeView implementation of the GtkBuildable interface accepts
 108  * #GtkTreeViewColumn objects as &lt;child&gt; elements and exposes the
 109  * internal #GtkTreeSelection in UI definitions.
 110  * <example>
 111  * <title>A UI definition fragment with GtkTreeView</title>
 112  * <programlisting><![CDATA[
 113  * <object class="GtkTreeView" id="treeview">
 114  *   <property name="model">liststore1</property>
 115  *   <child>
 116  *     <object class="GtkTreeViewColumn" id="test-column">
 117  *       <property name="title">Test</property>
 118  *       <child>
 119  *         <object class="GtkCellRendererText" id="test-renderer"/>
 120  *         <attributes>
 121  *           <attribute name="text">1</attribute>
 122  *         </attributes>
 123  *       </child>
 124  *     </object>
 125  *   </child>
 126  *   <child internal-child="selection">
 127  *     <object class="GtkTreeSelection" id="selection">
 128  *       <signal name="changed" handler="on_treeview_selection_changed"/>
 129  *     </object>
 130  *   </child>
 131  * </object>
 132  * ]]></programlisting>
 133  * </example>
 134  * </refsect2>
 135  */
 136
 137 enum
 138 {
 139   DRAG_COLUMN_WINDOW_STATE_UNSET = 0,
 140   DRAG_COLUMN_WINDOW_STATE_ORIGINAL = 1,
 141   DRAG_COLUMN_WINDOW_STATE_ARROW = 2,
 142   DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT = 3,
 143   DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT = 4
 144 };
 145
 146 enum
 147 {
 148   RUBBER_BAND_OFF = 0,
 149   RUBBER_BAND_MAYBE_START = 1,
 150   RUBBER_BAND_ACTIVE = 2
 151 };
 152
 153 typedef enum {
 154   CLEAR_AND_SELECT = (1 << 0),
 155   CLAMP_NODE       = (1 << 1),
 156   CURSOR_INVALID   = (1 << 2)
 157 } SetCursorFlags;
 158
 159  /* This lovely little value is used to determine how far away from the title bar
 160   * you can move the mouse and still have a column drag work.
 161   */
 162 #define TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER(tree_view) (10*gtk_tree_view_get_effective_header_height(tree_view))
 163
 164 #ifdef __GNUC__
 165
 166 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 167      if (!(expr))                                                       \
 168        {                                                                \
 169          g_log (G_LOG_DOMAIN,                                           \
 170                 G_LOG_LEVEL_CRITICAL,                                   \
 171                 "%s (%s): assertion `%s' failed.\n"                     \
 172                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 173                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 174                 "without letting the view know.  Any display from now on is likely to\n"  \
 175                 "be incorrect.\n",                                                        \
 176                 G_STRLOC,                                               \
 177                 G_STRFUNC,                                              \
 178                 #expr);                                                 \
 179          return ret;                                                    \
 180        };                               }G_STMT_END
 181
 182 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 183      if (!(expr))                                                       \
 184        {                                                                \
 185          g_log (G_LOG_DOMAIN,                                           \
 186                 G_LOG_LEVEL_CRITICAL,                                   \
 187                 "%s (%s): assertion `%s' failed.\n"                     \
 188                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 189                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 190                 "without letting the view know.  Any display from now on is likely to\n"  \
 191                 "be incorrect.\n",                                                        \
 192                 G_STRLOC,                                               \
 193                 G_STRFUNC,                                              \
 194                 #expr);                                                 \
 195          return;                                                        \
 196        };                               }G_STMT_END
 197
 198 #else
 199
 200 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 201      if (!(expr))                                                       \
 202        {                                                                \
 203          g_log (G_LOG_DOMAIN,                                           \
 204                 G_LOG_LEVEL_CRITICAL,                                   \
 205                 "file %s: line %d: assertion `%s' failed.\n"       \
 206                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 207                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 208                 "without letting the view know.  Any display from now on is likely to\n"  \
 209                 "be incorrect.\n",                                                        \
 210                 __FILE__,                                               \
 211                 __LINE__,                                               \
 212                 #expr);                                                 \
 213          return ret;                                                    \
 214        };                               }G_STMT_END
 215
 216 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 217      if (!(expr))                                                       \
 218        {                                                                \
 219          g_log (G_LOG_DOMAIN,                                           \
 220                 G_LOG_LEVEL_CRITICAL,                                   \
 221                 "file %s: line %d: assertion '%s' failed.\n"            \
 222                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 223                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 224                 "without letting the view know.  Any display from now on is likely to\n"  \
 225                 "be incorrect.\n",                                                        \
 226                 __FILE__,                                               \
 227                 __LINE__,                                               \
 228                 #expr);                                                 \
 229          return;                                                        \
 230        };                               }G_STMT_END
 231 #endif
 232
 233 #define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
 234 #define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2)
 235 #define GTK_TREE_VIEW_TIME_MS_PER_IDLE 30
 236 #define SCROLL_EDGE_SIZE 15
 237 #define EXPANDER_EXTRA_PADDING 4
 238 #define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000
 239 #define AUTO_EXPAND_TIMEOUT 500
 240
 241 /* Translate from bin_window coordinates to rbtree (tree coordinates) and
 242  * vice versa.
 243  */
 244 #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy)
 245 #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy)
 246
 247 typedef struct _GtkTreeViewColumnReorder GtkTreeViewColumnReorder;
 248 struct _GtkTreeViewColumnReorder
 249 {
 250   gint left_align;
 251   gint right_align;
 252   GtkTreeViewColumn *left_column;
 253   GtkTreeViewColumn *right_column;
 254 };
 255
 256 typedef struct _GtkTreeViewChild GtkTreeViewChild;
 257 struct _GtkTreeViewChild
 258 {
 259   GtkWidget *widget;
 260   gint x;
 261   gint y;
 262   gint width;
 263   gint height;
 264 };
 265
 266
 267 typedef struct _TreeViewDragInfo TreeViewDragInfo;
 268 struct _TreeViewDragInfo
 269 {
 270   GdkModifierType start_button_mask;
 271   GtkTargetList *_unused_source_target_list;
 272   GdkDragAction source_actions;
 273
 274   GtkTargetList *_unused_dest_target_list;
 275
 276   guint source_set : 1;
 277   guint dest_set : 1;
 278 };
 279
 280
 281 struct _GtkTreeViewPrivate
 282 {
 283   GtkTreeModel *model;
 284
 285   /* tree information */
 286   GtkRBTree *tree;
 287
 288   /* Container info */
 289   GList *children;
 290   gint width;
 291   gint height;
 292
 293   /* Adjustments */
 294   GtkAdjustment *hadjustment;
 295   GtkAdjustment *vadjustment;
 296   gint           min_display_width;
 297   gint           min_display_height;
 298
 299   /* Sub windows */
 300   GdkWindow *bin_window;
 301   GdkWindow *header_window;
 302
 303   /* Scroll position state keeping */
 304   GtkTreeRowReference *top_row;
 305   gint top_row_dy;
 306   /* dy == y pos of top_row + top_row_dy */
 307   /* we cache it for simplicity of the code */
 308   gint dy;
 309
 310   guint presize_handler_timer;
 311   guint validate_rows_timer;
 312   guint scroll_sync_timer;
 313
 314   /* Indentation and expander layout */
 315   gint expander_size;
 316   GtkTreeViewColumn *expander_column;
 317
 318   gint level_indentation;
 319
 320   /* Key navigation (focus), selection */
 321   gint cursor_offset;
 322
 323   GtkTreeRowReference *anchor;
 324   GtkRBNode *cursor_node;
 325   GtkRBTree *cursor_tree;
 326
 327   GtkTreeViewColumn *focus_column;
 328
 329   /* Current pressed node, previously pressed, prelight */
 330   GtkRBNode *button_pressed_node;
 331   GtkRBTree *button_pressed_tree;
 332
 333   gint pressed_button;
 334   gint press_start_x;
 335   gint press_start_y;
 336
 337   gint event_last_x;
 338   gint event_last_y;
 339
 340   guint last_button_time;
 341   gint last_button_x;
 342   gint last_button_y;
 343
 344   GtkRBNode *prelight_node;
 345   GtkRBTree *prelight_tree;
 346
 347   /* Cell Editing */
 348   GtkTreeViewColumn *edited_column;
 349
 350   /* The node that's currently being collapsed or expanded */
 351   GtkRBNode *expanded_collapsed_node;
 352   GtkRBTree *expanded_collapsed_tree;
 353   guint expand_collapse_timeout;
 354
 355   /* Auto expand/collapse timeout in hover mode */
 356   guint auto_expand_timeout;
 357
 358   /* Selection information */
 359   GtkTreeSelection *selection;
 360
 361   /* Header information */
 362   gint n_columns;
 363   GList *columns;
 364   gint header_height;
 365
 366   GtkTreeViewColumnDropFunc column_drop_func;
 367   gpointer column_drop_func_data;
 368   GDestroyNotify column_drop_func_data_destroy;
 369   GList *column_drag_info;
 370   GtkTreeViewColumnReorder *cur_reorder;
 371
 372   gint prev_width_before_expander;
 373
 374   /* Interactive Header reordering */
 375   GdkWindow *drag_window;
 376   GdkWindow *drag_highlight_window;
 377   GtkTreeViewColumn *drag_column;
 378   gint drag_column_x;
 379
 380   /* Interactive Header Resizing */
 381   gint drag_pos;
 382   gint x_drag;
 383
 384   /* Non-interactive Header Resizing, expand flag support */
 385   gint prev_width;
 386
 387   gint last_extra_space;
 388   gint last_extra_space_per_column;
 389   gint last_number_of_expand_columns;
 390
 391   /* ATK Hack */
 392   GtkTreeDestroyCountFunc destroy_count_func;
 393   gpointer destroy_count_data;
 394   GDestroyNotify destroy_count_destroy;
 395
 396   /* Scroll timeout (e.g. during dnd, rubber banding) */
 397   guint scroll_timeout;
 398
 399   /* Row drag-and-drop */
 400   GtkTreeRowReference *drag_dest_row;
 401   GtkTreeViewDropPosition drag_dest_pos;
 402   guint open_dest_timeout;
 403
 404   /* Rubber banding */
 405   gint rubber_band_status;
 406   gint rubber_band_x;
 407   gint rubber_band_y;
 408   gint rubber_band_extend;
 409   gint rubber_band_modify;
 410
 411   GtkRBNode *rubber_band_start_node;
 412   GtkRBTree *rubber_band_start_tree;
 413
 414   GtkRBNode *rubber_band_end_node;
 415   GtkRBTree *rubber_band_end_tree;
 416
 417   /* fixed height */
 418   gint fixed_height;
 419
 420   /* Scroll-to functionality when unrealized */
 421   GtkTreeRowReference *scroll_to_path;
 422   GtkTreeViewColumn *scroll_to_column;
 423   gfloat scroll_to_row_align;
 424   gfloat scroll_to_col_align;
 425
 426   /* Interactive search */
 427   gint selected_iter;
 428   gint search_column;
 429   GtkTreeViewSearchPositionFunc search_position_func;
 430   GtkTreeViewSearchEqualFunc search_equal_func;
 431   gpointer search_user_data;
 432   GDestroyNotify search_destroy;
 433   gpointer search_position_user_data;
 434   GDestroyNotify search_position_destroy;
 435   GtkWidget *search_window;
 436   GtkWidget *search_entry;
 437   gulong search_entry_changed_id;
 438   guint typeselect_flush_timeout;
 439
 440   /* Grid and tree lines */
 441   GtkTreeViewGridLines grid_lines;
 442   double grid_line_dashes[2];
 443   int grid_line_width;
 444
 445   gboolean tree_lines_enabled;
 446   double tree_line_dashes[2];
 447   int tree_line_width;
 448
 449   /* Row separators */
 450   GtkTreeViewRowSeparatorFunc row_separator_func;
 451   gpointer row_separator_data;
 452   GDestroyNotify row_separator_destroy;
 453
 454   /* Tooltip support */
 455   gint tooltip_column;
 456
 457   /* Here comes the bitfield */
 458   guint scroll_to_use_align : 1;
 459
 460   guint fixed_height_mode : 1;
 461   guint fixed_height_check : 1;
 462
 463   guint reorderable : 1;
 464   guint header_has_focus : 1;
 465   guint drag_column_window_state : 3;
 466   /* hint to display rows in alternating colors */
 467   guint has_rules : 1;
 468   guint mark_rows_col_dirty : 1;
 469
 470   /* for DnD */
 471   guint empty_view_drop : 1;
 472
 473   guint modify_selection_pressed : 1;
 474   guint extend_selection_pressed : 1;
 475
 476   guint init_hadjust_value : 1;
 477
 478   guint in_top_row_to_dy : 1;
 479
 480   /* interactive search */
 481   guint enable_search : 1;
 482   guint disable_popdown : 1;
 483   guint search_custom_entry_set : 1;
 484
 485   guint hover_selection : 1;
 486   guint hover_expand : 1;
 487   guint imcontext_changed : 1;
 488
 489   guint rubber_banding_enable : 1;
 490
 491   guint in_grab : 1;
 492
 493   guint post_validation_flag : 1;
 494
 495   /* Whether our key press handler is to avoid sending an unhandled binding to the search entry */
 496   guint search_entry_avoid_unhandled_binding : 1;
 497
 498   /* GtkScrollablePolicy needs to be checked when
 499    * driving the scrollable adjustment values */
 500   guint hscroll_policy : 1;
 501   guint vscroll_policy : 1;
 502
 503   /* GtkTreeView flags */
 504   guint is_list : 1;
 505   guint show_expanders : 1;
 506   guint in_column_resize : 1;
 507   guint arrow_prelit : 1;
 508   guint headers_visible : 1;
 509   guint draw_keyfocus : 1;
 510   guint model_setup : 1;
 511   guint in_column_drag : 1;
 512 };
 513
 514
 515 /* Signals */
 516 enum
 517 {
 518   ROW_ACTIVATED,
 519   TEST_EXPAND_ROW,
 520   TEST_COLLAPSE_ROW,
 521   ROW_EXPANDED,
 522   ROW_COLLAPSED,
 523   COLUMNS_CHANGED,
 524   CURSOR_CHANGED,
 525   MOVE_CURSOR,
 526   SELECT_ALL,
 527   UNSELECT_ALL,
 528   SELECT_CURSOR_ROW,
 529   TOGGLE_CURSOR_ROW,
 530   EXPAND_COLLAPSE_CURSOR_ROW,
 531   SELECT_CURSOR_PARENT,
 532   START_INTERACTIVE_SEARCH,
 533   LAST_SIGNAL
 534 };
 535
 536 /* Properties */
 537 enum {
 538   PROP_0,
 539   PROP_MODEL,
 540   PROP_HADJUSTMENT,
 541   PROP_VADJUSTMENT,
 542   PROP_HSCROLL_POLICY,
 543   PROP_VSCROLL_POLICY,
 544   PROP_HEADERS_VISIBLE,
 545   PROP_HEADERS_CLICKABLE,
 546   PROP_EXPANDER_COLUMN,
 547   PROP_REORDERABLE,
 548   PROP_RULES_HINT,
 549   PROP_ENABLE_SEARCH,
 550   PROP_SEARCH_COLUMN,
 551   PROP_FIXED_HEIGHT_MODE,
 552   PROP_HOVER_SELECTION,
 553   PROP_HOVER_EXPAND,
 554   PROP_SHOW_EXPANDERS,
 555   PROP_LEVEL_INDENTATION,
 556   PROP_RUBBER_BANDING,
 557   PROP_ENABLE_GRID_LINES,
 558   PROP_ENABLE_TREE_LINES,
 559   PROP_TOOLTIP_COLUMN
 560 };
 561
 562 /* object signals */
 563 static void     gtk_tree_view_finalize             (GObject          *object);
 564 static void     gtk_tree_view_set_property         (GObject         *object,
 565                                                     guint            prop_id,
 566                                                     const GValue    *value,
 567                                                     GParamSpec      *pspec);
 568 static void     gtk_tree_view_get_property         (GObject         *object,
 569                                                     guint            prop_id,
 570                                                     GValue          *value,
 571                                                     GParamSpec      *pspec);
 572
 573 /* gtkwidget signals */
 574 static void     gtk_tree_view_destroy              (GtkWidget        *widget);
 575 static void     gtk_tree_view_realize              (GtkWidget        *widget);
 576 static void     gtk_tree_view_unrealize            (GtkWidget        *widget);
 577 static void     gtk_tree_view_map                  (GtkWidget        *widget);
 578 static void     gtk_tree_view_get_preferred_width  (GtkWidget        *widget,
 579                                                     gint             *minimum,
 580                                                     gint             *natural);
 581 static void     gtk_tree_view_get_preferred_height (GtkWidget        *widget,
 582                                                     gint             *minimum,
 583                                                     gint             *natural);
 584 static void     gtk_tree_view_size_request         (GtkWidget        *widget,
 585                                                     GtkRequisition   *requisition,
 586                                                     gboolean          may_validate);
 587 static void     gtk_tree_view_size_allocate        (GtkWidget        *widget,
 588                                                     GtkAllocation    *allocation);
 589 static gboolean gtk_tree_view_draw                 (GtkWidget        *widget,
 590                                                     cairo_t          *cr);
 591 static gboolean gtk_tree_view_key_press            (GtkWidget        *widget,
 592                                                     GdkEventKey      *event);
 593 static gboolean gtk_tree_view_key_release          (GtkWidget        *widget,
 594                                                     GdkEventKey      *event);
 595 static gboolean gtk_tree_view_motion               (GtkWidget        *widget,
 596                                                     GdkEventMotion   *event);
 597 static gboolean gtk_tree_view_enter_notify         (GtkWidget        *widget,
 598                                                     GdkEventCrossing *event);
 599 static gboolean gtk_tree_view_leave_notify         (GtkWidget        *widget,
 600                                                     GdkEventCrossing *event);
 601 static gboolean gtk_tree_view_button_press         (GtkWidget        *widget,
 602                                                     GdkEventButton   *event);
 603 static gboolean gtk_tree_view_button_release       (GtkWidget        *widget,
 604                                                     GdkEventButton   *event);
 605 static gboolean gtk_tree_view_grab_broken          (GtkWidget          *widget,
 606                                                     GdkEventGrabBroken *event);
 607 #if 0
 608 static gboolean gtk_tree_view_configure            (GtkWidget         *widget,
 609                                                     GdkEventConfigure *event);
 610 #endif
 611
 612 static GtkWidgetPath * gtk_tree_view_get_path_for_child (GtkContainer *container,
 613                                                          GtkWidget    *child);
 614
 615 static void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 616                                                     GtkWidget        *child);
 617 static gint     gtk_tree_view_focus_out            (GtkWidget        *widget,
 618                                                     GdkEventFocus    *event);
 619 static gint     gtk_tree_view_focus                (GtkWidget        *widget,
 620                                                     GtkDirectionType  direction);
 621 static void     gtk_tree_view_grab_focus           (GtkWidget        *widget);
 622 static void     gtk_tree_view_style_updated        (GtkWidget        *widget);
 623 static void     gtk_tree_view_grab_notify          (GtkWidget        *widget,
 624                                                     gboolean          was_grabbed);
 625 static void     gtk_tree_view_state_flags_changed  (GtkWidget        *widget,
 626                                                     GtkStateFlags     previous_state);
 627
 628 /* container signals */
 629 static void     gtk_tree_view_remove               (GtkContainer     *container,
 630                                                     GtkWidget        *widget);
 631 static void     gtk_tree_view_forall               (GtkContainer     *container,
 632                                                     gboolean          include_internals,
 633                                                     GtkCallback       callback,
 634                                                     gpointer          callback_data);
 635
 636 /* Source side drag signals */
 637 static void gtk_tree_view_drag_begin       (GtkWidget        *widget,
 638                                             GdkDragContext   *context);
 639 static void gtk_tree_view_drag_end         (GtkWidget        *widget,
 640                                             GdkDragContext   *context);
 641 static void gtk_tree_view_drag_data_get    (GtkWidget        *widget,
 642                                             GdkDragContext   *context,
 643                                             GtkSelectionData *selection_data,
 644                                             guint             info,
 645                                             guint             time);
 646 static void gtk_tree_view_drag_data_delete (GtkWidget        *widget,
 647                                             GdkDragContext   *context);
 648
 649 /* Target side drag signals */
 650 static void     gtk_tree_view_drag_leave         (GtkWidget        *widget,
 651                                                   GdkDragContext   *context,
 652                                                   guint             time);
 653 static gboolean gtk_tree_view_drag_motion        (GtkWidget        *widget,
 654                                                   GdkDragContext   *context,
 655                                                   gint              x,
 656                                                   gint              y,
 657                                                   guint             time);
 658 static gboolean gtk_tree_view_drag_drop          (GtkWidget        *widget,
 659                                                   GdkDragContext   *context,
 660                                                   gint              x,
 661                                                   gint              y,
 662                                                   guint             time);
 663 static void     gtk_tree_view_drag_data_received (GtkWidget        *widget,
 664                                                   GdkDragContext   *context,
 665                                                   gint              x,
 666                                                   gint              y,
 667                                                   GtkSelectionData *selection_data,
 668                                                   guint             info,
 669                                                   guint             time);
 670
 671 /* tree_model signals */
 672 static gboolean gtk_tree_view_real_move_cursor            (GtkTreeView     *tree_view,
 673                                                            GtkMovementStep  step,
 674                                                            gint             count);
 675 static gboolean gtk_tree_view_real_select_all             (GtkTreeView     *tree_view);
 676 static gboolean gtk_tree_view_real_unselect_all           (GtkTreeView     *tree_view);
 677 static gboolean gtk_tree_view_real_select_cursor_row      (GtkTreeView     *tree_view,
 678                                                            gboolean         start_editing);
 679 static gboolean gtk_tree_view_real_toggle_cursor_row      (GtkTreeView     *tree_view);
 680 static gboolean gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView     *tree_view,
 681                                                                gboolean         logical,
 682                                                                gboolean         expand,
 683                                                                gboolean         open_all);
 684 static gboolean gtk_tree_view_real_select_cursor_parent   (GtkTreeView     *tree_view);
 685 static void gtk_tree_view_row_changed                     (GtkTreeModel    *model,
 686                                                            GtkTreePath     *path,
 687                                                            GtkTreeIter     *iter,
 688                                                            gpointer         data);
 689 static void gtk_tree_view_row_inserted                    (GtkTreeModel    *model,
 690                                                            GtkTreePath     *path,
 691                                                            GtkTreeIter     *iter,
 692                                                            gpointer         data);
 693 static void gtk_tree_view_row_has_child_toggled           (GtkTreeModel    *model,
 694                                                            GtkTreePath     *path,
 695                                                            GtkTreeIter     *iter,
 696                                                            gpointer         data);
 697 static void gtk_tree_view_row_deleted                     (GtkTreeModel    *model,
 698                                                            GtkTreePath     *path,
 699                                                            gpointer         data);
 700 static void gtk_tree_view_rows_reordered                  (GtkTreeModel    *model,
 701                                                            GtkTreePath     *parent,
 702                                                            GtkTreeIter     *iter,
 703                                                            gint            *new_order,
 704                                                            gpointer         data);
 705
 706 /* Incremental reflow */
 707 static gboolean validate_row             (GtkTreeView *tree_view,
 708                                           GtkRBTree   *tree,
 709                                           GtkRBNode   *node,
 710                                           GtkTreeIter *iter,
 711                                           GtkTreePath *path);
 712 static void     validate_visible_area    (GtkTreeView *tree_view);
 713 static gboolean validate_rows_handler    (GtkTreeView *tree_view);
 714 static gboolean do_validate_rows         (GtkTreeView *tree_view,
 715                                           gboolean     size_request);
 716 static gboolean validate_rows            (GtkTreeView *tree_view);
 717 static gboolean presize_handler_callback (gpointer     data);
 718 static void     install_presize_handler  (GtkTreeView *tree_view);
 719 static void     install_scroll_sync_handler (GtkTreeView *tree_view);
 720 static void     gtk_tree_view_set_top_row   (GtkTreeView *tree_view,
 721                                              GtkTreePath *path,
 722                                              gint         offset);
 723 static void     gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view);
 724 static void     gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view);
 725 static void     invalidate_empty_focus      (GtkTreeView *tree_view);
 726
 727 /* Internal functions */
 728 static gboolean gtk_tree_view_is_expander_column             (GtkTreeView        *tree_view,
 729                                                               GtkTreeViewColumn  *column);
 730 static inline gboolean gtk_tree_view_draw_expanders          (GtkTreeView        *tree_view);
 731 static void     gtk_tree_view_add_move_binding               (GtkBindingSet      *binding_set,
 732                                                               guint               keyval,
 733                                                               guint               modmask,
 734                                                               gboolean            add_shifted_binding,
 735                                                               GtkMovementStep     step,
 736                                                               gint                count);
 737 static gint     gtk_tree_view_unref_and_check_selection_tree (GtkTreeView        *tree_view,
 738                                                               GtkRBTree          *tree);
 739 static void     gtk_tree_view_queue_draw_path                (GtkTreeView        *tree_view,
 740                                                               GtkTreePath        *path,
 741                                                               const GdkRectangle *clip_rect);
 742 static void     gtk_tree_view_queue_draw_arrow               (GtkTreeView        *tree_view,
 743                                                               GtkRBTree          *tree,
 744                                                               GtkRBNode          *node);
 745 static void     gtk_tree_view_draw_arrow                     (GtkTreeView        *tree_view,
 746                                                               cairo_t            *cr,
 747                                                               GtkRBTree          *tree,
 748                                                               GtkRBNode          *node);
 749 static void     gtk_tree_view_get_arrow_xrange               (GtkTreeView        *tree_view,
 750                                                               GtkRBTree          *tree,
 751                                                               gint               *x1,
 752                                                               gint               *x2);
 753 static gint     gtk_tree_view_new_column_width               (GtkTreeView        *tree_view,
 754                                                               gint                i,
 755                                                               gint               *x);
 756 static void     gtk_tree_view_adjustment_changed             (GtkAdjustment      *adjustment,
 757                                                               GtkTreeView        *tree_view);
 758 static void     gtk_tree_view_build_tree                     (GtkTreeView        *tree_view,
 759                                                               GtkRBTree          *tree,
 760                                                               GtkTreeIter        *iter,
 761                                                               gint                depth,
 762                                                               gboolean            recurse);
 763 static void     gtk_tree_view_clamp_node_visible             (GtkTreeView        *tree_view,
 764                                                               GtkRBTree          *tree,
 765                                                               GtkRBNode          *node);
 766 static void     gtk_tree_view_clamp_column_visible           (GtkTreeView        *tree_view,
 767                                                               GtkTreeViewColumn  *column,
 768                                                               gboolean            focus_to_cell);
 769 static gboolean gtk_tree_view_maybe_begin_dragging_row       (GtkTreeView        *tree_view,
 770                                                               GdkEventMotion     *event);
 771 static void     gtk_tree_view_focus_to_cursor                (GtkTreeView        *tree_view);
 772 static void     gtk_tree_view_move_cursor_up_down            (GtkTreeView        *tree_view,
 773                                                               gint                count);
 774 static void     gtk_tree_view_move_cursor_page_up_down       (GtkTreeView        *tree_view,
 775                                                               gint                count);
 776 static void     gtk_tree_view_move_cursor_left_right         (GtkTreeView        *tree_view,
 777                                                               gint                count);
 778 static void     gtk_tree_view_move_cursor_start_end          (GtkTreeView        *tree_view,
 779                                                               gint                count);
 780 static gboolean gtk_tree_view_real_collapse_row              (GtkTreeView        *tree_view,
 781                                                               GtkTreePath        *path,
 782                                                               GtkRBTree          *tree,
 783                                                               GtkRBNode          *node,
 784                                                               gboolean            animate);
 785 static gboolean gtk_tree_view_real_expand_row                (GtkTreeView        *tree_view,
 786                                                               GtkTreePath        *path,
 787                                                               GtkRBTree          *tree,
 788                                                               GtkRBNode          *node,
 789                                                               gboolean            open_all,
 790                                                               gboolean            animate);
 791 static void     gtk_tree_view_real_set_cursor                (GtkTreeView        *tree_view,
 792                                                               GtkTreePath        *path,
 793                                                               SetCursorFlags      flags);
 794 static gboolean gtk_tree_view_has_can_focus_cell             (GtkTreeView        *tree_view);
 795 static void     column_sizing_notify                         (GObject            *object,
 796                                                               GParamSpec         *pspec,
 797                                                               gpointer            data);
 798 static void     gtk_tree_view_stop_rubber_band               (GtkTreeView        *tree_view);
 799 static void     update_prelight                              (GtkTreeView        *tree_view,
 800                                                               int                 x,
 801                                                               int                 y);
 802
 803 static inline gint gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view);
 804
 805 static inline gint gtk_tree_view_get_cell_area_y_offset      (GtkTreeView *tree_view,
 806                                                               GtkRBTree   *tree,
 807                                                               GtkRBNode   *node,
 808                                                               gint         vertical_separator);
 809 static inline gint gtk_tree_view_get_cell_area_height        (GtkTreeView *tree_view,
 810                                                               GtkRBNode   *node,
 811                                                               gint         vertical_separator);
 812
 813 static inline gint gtk_tree_view_get_row_y_offset            (GtkTreeView *tree_view,
 814                                                               GtkRBTree   *tree,
 815                                                               GtkRBNode   *node);
 816 static inline gint gtk_tree_view_get_row_height              (GtkTreeView *tree_view,
 817                                                               GtkRBNode   *node);
 818
 819 /* interactive search */
 820 static void     gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view);
 821 static void     gtk_tree_view_search_dialog_hide        (GtkWidget        *search_dialog,
 822                                                          GtkTreeView      *tree_view,
 823                                                          GdkDevice        *device);
 824 static void     gtk_tree_view_search_position_func      (GtkTreeView      *tree_view,
 825                                                          GtkWidget        *search_dialog,
 826                                                          gpointer          user_data);
 827 static void     gtk_tree_view_search_disable_popdown    (GtkEntry         *entry,
 828                                                          GtkMenu          *menu,
 829                                                          gpointer          data);
 830 static void     gtk_tree_view_search_preedit_changed    (GtkIMContext     *im_context,
 831                                                          GtkTreeView      *tree_view);
 832 static void     gtk_tree_view_search_activate           (GtkEntry         *entry,
 833                                                          GtkTreeView      *tree_view);
 834 static gboolean gtk_tree_view_real_search_enable_popdown(gpointer          data);
 835 static void     gtk_tree_view_search_enable_popdown     (GtkWidget        *widget,
 836                                                          gpointer          data);
 837 static gboolean gtk_tree_view_search_delete_event       (GtkWidget        *widget,
 838                                                          GdkEventAny      *event,
 839                                                          GtkTreeView      *tree_view);
 840 static gboolean gtk_tree_view_search_button_press_event (GtkWidget        *widget,
 841                                                          GdkEventButton   *event,
 842                                                          GtkTreeView      *tree_view);
 843 static gboolean gtk_tree_view_search_scroll_event       (GtkWidget        *entry,
 844                                                          GdkEventScroll   *event,
 845                                                          GtkTreeView      *tree_view);
 846 static gboolean gtk_tree_view_search_key_press_event    (GtkWidget        *entry,
 847                                                          GdkEventKey      *event,
 848                                                          GtkTreeView      *tree_view);
 849 static gboolean gtk_tree_view_search_move               (GtkWidget        *window,
 850                                                          GtkTreeView      *tree_view,
 851                                                          gboolean          up);
 852 static gboolean gtk_tree_view_search_equal_func         (GtkTreeModel     *model,
 853                                                          gint              column,
 854                                                          const gchar      *key,
 855                                                          GtkTreeIter      *iter,
 856                                                          gpointer          search_data);
 857 static gboolean gtk_tree_view_search_iter               (GtkTreeModel     *model,
 858                                                          GtkTreeSelection *selection,
 859                                                          GtkTreeIter      *iter,
 860                                                          const gchar      *text,
 861                                                          gint             *count,
 862                                                          gint              n);
 863 static void     gtk_tree_view_search_init               (GtkWidget        *entry,
 864                                                          GtkTreeView      *tree_view);
 865 static void     gtk_tree_view_put                       (GtkTreeView      *tree_view,
 866                                                          GtkWidget        *child_widget,
 867                                                          gint              x,
 868                                                          gint              y,
 869                                                          gint              width,
 870                                                          gint              height);
 871 static gboolean gtk_tree_view_start_editing             (GtkTreeView      *tree_view,
 872                                                          GtkTreePath      *cursor_path,
 873                                                          gboolean          edit_only);
 874 static void gtk_tree_view_stop_editing                  (GtkTreeView *tree_view,
 875                                                          gboolean     cancel_editing);
 876 static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
 877                                                              GdkDevice   *device,
 878                                                              gboolean     keybinding);
 879 static gboolean gtk_tree_view_start_interactive_search      (GtkTreeView *tree_view);
 880 static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
 881                                                          GtkTreeViewColumn *column,
 882                                                          gint               drop_position);
 883
 884 /* GtkBuildable */
 885 static void     gtk_tree_view_buildable_add_child          (GtkBuildable      *tree_view,
 886                                                             GtkBuilder        *builder,
 887                                                             GObject           *child,
 888                                                             const gchar       *type);
 889 static GObject *gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
 890                                                             GtkBuilder        *builder,
 891                                                             const gchar       *childname);
 892 static void     gtk_tree_view_buildable_init               (GtkBuildableIface *iface);
 893
 894 static GtkAdjustment *gtk_tree_view_do_get_hadjustment (GtkTreeView   *tree_view);
 895 static void           gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
 896                                                         GtkAdjustment *adjustment);
 897 static GtkAdjustment *gtk_tree_view_do_get_vadjustment (GtkTreeView   *tree_view);
 898 static void           gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
 899                                                         GtkAdjustment *adjustment);
 900
 901 static gboolean scroll_row_timeout                   (gpointer     data);
 902 static void     add_scroll_timeout                   (GtkTreeView *tree_view);
 903 static void     remove_scroll_timeout                (GtkTreeView *tree_view);
 904
 905 static guint tree_view_signals [LAST_SIGNAL] = { 0 };
 906
 907 \f
 908
 909 /* GType Methods
 910  */
 911
 912 G_DEFINE_TYPE_WITH_CODE (GtkTreeView, gtk_tree_view, GTK_TYPE_CONTAINER,
 913                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 914                                                 gtk_tree_view_buildable_init)
 915                          G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
 916
 917 static void
 918 gtk_tree_view_class_init (GtkTreeViewClass *class)
 919 {
 920   GObjectClass *o_class;
 921   GtkWidgetClass *widget_class;
 922   GtkContainerClass *container_class;
 923   GtkBindingSet *binding_set;
 924
 925   binding_set = gtk_binding_set_by_class (class);
 926
 927   o_class = (GObjectClass *) class;
 928   widget_class = (GtkWidgetClass *) class;
 929   container_class = (GtkContainerClass *) class;
 930
 931   /* GObject signals */
 932   o_class->set_property = gtk_tree_view_set_property;
 933   o_class->get_property = gtk_tree_view_get_property;
 934   o_class->finalize = gtk_tree_view_finalize;
 935
 936   /* GtkWidget signals */
 937   widget_class->destroy = gtk_tree_view_destroy;
 938   widget_class->map = gtk_tree_view_map;
 939   widget_class->realize = gtk_tree_view_realize;
 940   widget_class->unrealize = gtk_tree_view_unrealize;
 941   widget_class->get_preferred_width = gtk_tree_view_get_preferred_width;
 942   widget_class->get_preferred_height = gtk_tree_view_get_preferred_height;
 943   widget_class->size_allocate = gtk_tree_view_size_allocate;
 944   widget_class->button_press_event = gtk_tree_view_button_press;
 945   widget_class->button_release_event = gtk_tree_view_button_release;
 946   widget_class->grab_broken_event = gtk_tree_view_grab_broken;
 947   /*widget_class->configure_event = gtk_tree_view_configure;*/
 948   widget_class->motion_notify_event = gtk_tree_view_motion;
 949   widget_class->draw = gtk_tree_view_draw;
 950   widget_class->key_press_event = gtk_tree_view_key_press;
 951   widget_class->key_release_event = gtk_tree_view_key_release;
 952   widget_class->enter_notify_event = gtk_tree_view_enter_notify;
 953   widget_class->leave_notify_event = gtk_tree_view_leave_notify;
 954   widget_class->focus_out_event = gtk_tree_view_focus_out;
 955   widget_class->drag_begin = gtk_tree_view_drag_begin;
 956   widget_class->drag_end = gtk_tree_view_drag_end;
 957   widget_class->drag_data_get = gtk_tree_view_drag_data_get;
 958   widget_class->drag_data_delete = gtk_tree_view_drag_data_delete;
 959   widget_class->drag_leave = gtk_tree_view_drag_leave;
 960   widget_class->drag_motion = gtk_tree_view_drag_motion;
 961   widget_class->drag_drop = gtk_tree_view_drag_drop;
 962   widget_class->drag_data_received = gtk_tree_view_drag_data_received;
 963   widget_class->focus = gtk_tree_view_focus;
 964   widget_class->grab_focus = gtk_tree_view_grab_focus;
 965   widget_class->style_updated = gtk_tree_view_style_updated;
 966   widget_class->grab_notify = gtk_tree_view_grab_notify;
 967   widget_class->state_flags_changed = gtk_tree_view_state_flags_changed;
 968
 969   /* GtkContainer signals */
 970   container_class->remove = gtk_tree_view_remove;
 971   container_class->forall = gtk_tree_view_forall;
 972   container_class->set_focus_child = gtk_tree_view_set_focus_child;
 973   container_class->get_path_for_child = gtk_tree_view_get_path_for_child;
 974
 975   class->move_cursor = gtk_tree_view_real_move_cursor;
 976   class->select_all = gtk_tree_view_real_select_all;
 977   class->unselect_all = gtk_tree_view_real_unselect_all;
 978   class->select_cursor_row = gtk_tree_view_real_select_cursor_row;
 979   class->toggle_cursor_row = gtk_tree_view_real_toggle_cursor_row;
 980   class->expand_collapse_cursor_row = gtk_tree_view_real_expand_collapse_cursor_row;
 981   class->select_cursor_parent = gtk_tree_view_real_select_cursor_parent;
 982   class->start_interactive_search = gtk_tree_view_start_interactive_search;
 983
 984   /* Properties */
 985
 986   g_object_class_install_property (o_class,
 987                                    PROP_MODEL,
 988                                    g_param_spec_object ("model",
 989                                                         P_("TreeView Model"),
 990                                                         P_("The model for the tree view"),
 991                                                         GTK_TYPE_TREE_MODEL,
 992                                                         GTK_PARAM_READWRITE));
 993
 994   g_object_class_override_property (o_class, PROP_HADJUSTMENT,    "hadjustment");
 995   g_object_class_override_property (o_class, PROP_VADJUSTMENT,    "vadjustment");
 996   g_object_class_override_property (o_class, PROP_HSCROLL_POLICY, "hscroll-policy");
 997   g_object_class_override_property (o_class, PROP_VSCROLL_POLICY, "vscroll-policy");
 998
 999   g_object_class_install_property (o_class,
1000                                    PROP_HEADERS_VISIBLE,
1001                                    g_param_spec_boolean ("headers-visible",
1002                                                          P_("Headers Visible"),
1003                                                          P_("Show the column header buttons"),
1004                                                          TRUE,
1005                                                          GTK_PARAM_READWRITE));
1006
1007   g_object_class_install_property (o_class,
1008                                    PROP_HEADERS_CLICKABLE,
1009                                    g_param_spec_boolean ("headers-clickable",
1010                                                          P_("Headers Clickable"),
1011                                                          P_("Column headers respond to click events"),
1012                                                          TRUE,
1013                                                          GTK_PARAM_READWRITE));
1014
1015   g_object_class_install_property (o_class,
1016                                    PROP_EXPANDER_COLUMN,
1017                                    g_param_spec_object ("expander-column",
1018                                                         P_("Expander Column"),
1019                                                         P_("Set the column for the expander column"),
1020                                                         GTK_TYPE_TREE_VIEW_COLUMN,
1021                                                         GTK_PARAM_READWRITE));
1022
1023   g_object_class_install_property (o_class,
1024                                    PROP_REORDERABLE,
1025                                    g_param_spec_boolean ("reorderable",
1026                                                          P_("Reorderable"),
1027                                                          P_("View is reorderable"),
1028                                                          FALSE,
1029                                                          GTK_PARAM_READWRITE));
1030
1031   g_object_class_install_property (o_class,
1032                                    PROP_RULES_HINT,
1033                                    g_param_spec_boolean ("rules-hint",
1034                                                          P_("Rules Hint"),
1035                                                          P_("Set a hint to the theme engine to draw rows in alternating colors"),
1036                                                          FALSE,
1037                                                          GTK_PARAM_READWRITE));
1038
1039     g_object_class_install_property (o_class,
1040                                      PROP_ENABLE_SEARCH,
1041                                      g_param_spec_boolean ("enable-search",
1042                                                            P_("Enable Search"),
1043                                                            P_("View allows user to search through columns interactively"),
1044                                                            TRUE,
1045                                                            GTK_PARAM_READWRITE));
1046
1047     g_object_class_install_property (o_class,
1048                                      PROP_SEARCH_COLUMN,
1049                                      g_param_spec_int ("search-column",
1050                                                        P_("Search Column"),
1051                                                        P_("Model column to search through during interactive search"),
1052                                                        -1,
1053                                                        G_MAXINT,
1054                                                        -1,
1055                                                        GTK_PARAM_READWRITE));
1056
1057     /**
1058      * GtkTreeView:fixed-height-mode:
1059      *
1060      * Setting the ::fixed-height-mode property to %TRUE speeds up
1061      * #GtkTreeView by assuming that all rows have the same height.
1062      * Only enable this option if all rows are the same height.
1063      * Please see gtk_tree_view_set_fixed_height_mode() for more
1064      * information on this option.
1065      *
1066      * Since: 2.4
1067      **/
1068     g_object_class_install_property (o_class,
1069                                      PROP_FIXED_HEIGHT_MODE,
1070                                      g_param_spec_boolean ("fixed-height-mode",
1071                                                            P_("Fixed Height Mode"),
1072                                                            P_("Speeds up GtkTreeView by assuming that all rows have the same height"),
1073                                                            FALSE,
1074                                                            GTK_PARAM_READWRITE));
1075
1076     /**
1077      * GtkTreeView:hover-selection:
1078      *
1079      * Enables or disables the hover selection mode of @tree_view.
1080      * Hover selection makes the selected row follow the pointer.
1081      * Currently, this works only for the selection modes
1082      * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
1083      *
1084      * This mode is primarily intended for treeviews in popups, e.g.
1085      * in #GtkComboBox or #GtkEntryCompletion.
1086      *
1087      * Since: 2.6
1088      */
1089     g_object_class_install_property (o_class,
1090                                      PROP_HOVER_SELECTION,
1091                                      g_param_spec_boolean ("hover-selection",
1092                                                            P_("Hover Selection"),
1093                                                            P_("Whether the selection should follow the pointer"),
1094                                                            FALSE,
1095                                                            GTK_PARAM_READWRITE));
1096
1097     /**
1098      * GtkTreeView:hover-expand:
1099      *
1100      * Enables or disables the hover expansion mode of @tree_view.
1101      * Hover expansion makes rows expand or collapse if the pointer moves
1102      * over them.
1103      *
1104      * This mode is primarily intended for treeviews in popups, e.g.
1105      * in #GtkComboBox or #GtkEntryCompletion.
1106      *
1107      * Since: 2.6
1108      */
1109     g_object_class_install_property (o_class,
1110                                      PROP_HOVER_EXPAND,
1111                                      g_param_spec_boolean ("hover-expand",
1112                                                            P_("Hover Expand"),
1113                                                            P_("Whether rows should be expanded/collapsed when the pointer moves over them"),
1114                                                            FALSE,
1115                                                            GTK_PARAM_READWRITE));
1116
1117     /**
1118      * GtkTreeView:show-expanders:
1119      *
1120      * %TRUE if the view has expanders.
1121      *
1122      * Since: 2.12
1123      */
1124     g_object_class_install_property (o_class,
1125                                      PROP_SHOW_EXPANDERS,
1126                                      g_param_spec_boolean ("show-expanders",
1127                                                            P_("Show Expanders"),
1128                                                            P_("View has expanders"),
1129                                                            TRUE,
1130                                                            GTK_PARAM_READWRITE));
1131
1132     /**
1133      * GtkTreeView:level-indentation:
1134      *
1135      * Extra indentation for each level.
1136      *
1137      * Since: 2.12
1138      */
1139     g_object_class_install_property (o_class,
1140                                      PROP_LEVEL_INDENTATION,
1141                                      g_param_spec_int ("level-indentation",
1142                                                        P_("Level Indentation"),
1143                                                        P_("Extra indentation for each level"),
1144                                                        0,
1145                                                        G_MAXINT,
1146                                                        0,
1147                                                        GTK_PARAM_READWRITE));
1148
1149     g_object_class_install_property (o_class,
1150                                      PROP_RUBBER_BANDING,
1151                                      g_param_spec_boolean ("rubber-banding",
1152                                                            P_("Rubber Banding"),
1153                                                            P_("Whether to enable selection of multiple items by dragging the mouse pointer"),
1154                                                            FALSE,
1155                                                            GTK_PARAM_READWRITE));
1156
1157     g_object_class_install_property (o_class,
1158                                      PROP_ENABLE_GRID_LINES,
1159                                      g_param_spec_enum ("enable-grid-lines",
1160                                                         P_("Enable Grid Lines"),
1161                                                         P_("Whether grid lines should be drawn in the tree view"),
1162                                                         GTK_TYPE_TREE_VIEW_GRID_LINES,
1163                                                         GTK_TREE_VIEW_GRID_LINES_NONE,
1164                                                         GTK_PARAM_READWRITE));
1165
1166     g_object_class_install_property (o_class,
1167                                      PROP_ENABLE_TREE_LINES,
1168                                      g_param_spec_boolean ("enable-tree-lines",
1169                                                            P_("Enable Tree Lines"),
1170                                                            P_("Whether tree lines should be drawn in the tree view"),
1171                                                            FALSE,
1172                                                            GTK_PARAM_READWRITE));
1173
1174     g_object_class_install_property (o_class,
1175                                      PROP_TOOLTIP_COLUMN,
1176                                      g_param_spec_int ("tooltip-column",
1177                                                        P_("Tooltip Column"),
1178                                                        P_("The column in the model containing the tooltip texts for the rows"),
1179                                                        -1,
1180                                                        G_MAXINT,
1181                                                        -1,
1182                                                        GTK_PARAM_READWRITE));
1183
1184   /* Style properties */
1185 #define _TREE_VIEW_EXPANDER_SIZE 14
1186 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
1187 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
1188
1189   gtk_widget_class_install_style_property (widget_class,
1190                                            g_param_spec_int ("expander-size",
1191                                                              P_("Expander Size"),
1192                                                              P_("Size of the expander arrow"),
1193                                                              0,
1194                                                              G_MAXINT,
1195                                                              _TREE_VIEW_EXPANDER_SIZE,
1196                                                              GTK_PARAM_READABLE));
1197
1198   gtk_widget_class_install_style_property (widget_class,
1199                                            g_param_spec_int ("vertical-separator",
1200                                                              P_("Vertical Separator Width"),
1201                                                              P_("Vertical space between cells.  Must be an even number"),
1202                                                              0,
1203                                                              G_MAXINT,
1204                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
1205                                                              GTK_PARAM_READABLE));
1206
1207   gtk_widget_class_install_style_property (widget_class,
1208                                            g_param_spec_int ("horizontal-separator",
1209                                                              P_("Horizontal Separator Width"),
1210                                                              P_("Horizontal space between cells.  Must be an even number"),
1211                                                              0,
1212                                                              G_MAXINT,
1213                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
1214                                                              GTK_PARAM_READABLE));
1215
1216   gtk_widget_class_install_style_property (widget_class,
1217                                            g_param_spec_boolean ("allow-rules",
1218                                                                  P_("Allow Rules"),
1219                                                                  P_("Allow drawing of alternating color rows"),
1220                                                                  TRUE,
1221                                                                  GTK_PARAM_READABLE));
1222
1223   gtk_widget_class_install_style_property (widget_class,
1224                                            g_param_spec_boolean ("indent-expanders",
1225                                                                  P_("Indent Expanders"),
1226                                                                  P_("Make the expanders indented"),
1227                                                                  TRUE,
1228                                                                  GTK_PARAM_READABLE));
1229
1230   gtk_widget_class_install_style_property (widget_class,
1231                                            g_param_spec_boxed ("even-row-color",
1232                                                                P_("Even Row Color"),
1233                                                                P_("Color to use for even rows"),
1234                                                                GDK_TYPE_COLOR,
1235                                                                GTK_PARAM_READABLE));
1236
1237   gtk_widget_class_install_style_property (widget_class,
1238                                            g_param_spec_boxed ("odd-row-color",
1239                                                                P_("Odd Row Color"),
1240                                                                P_("Color to use for odd rows"),
1241                                                                GDK_TYPE_COLOR,
1242                                                                GTK_PARAM_READABLE));
1243
1244   gtk_widget_class_install_style_property (widget_class,
1245                                            g_param_spec_int ("grid-line-width",
1246                                                              P_("Grid line width"),
1247                                                              P_("Width, in pixels, of the tree view grid lines"),
1248                                                              0, G_MAXINT, 1,
1249                                                              GTK_PARAM_READABLE));
1250
1251   gtk_widget_class_install_style_property (widget_class,
1252                                            g_param_spec_int ("tree-line-width",
1253                                                              P_("Tree line width"),
1254                                                              P_("Width, in pixels, of the tree view lines"),
1255                                                              0, G_MAXINT, 1,
1256                                                              GTK_PARAM_READABLE));
1257
1258   gtk_widget_class_install_style_property (widget_class,
1259                                            g_param_spec_string ("grid-line-pattern",
1260                                                                 P_("Grid line pattern"),
1261                                                                 P_("Dash pattern used to draw the tree view grid lines"),
1262                                                                 "\1\1",
1263                                                                 GTK_PARAM_READABLE));
1264
1265   gtk_widget_class_install_style_property (widget_class,
1266                                            g_param_spec_string ("tree-line-pattern",
1267                                                                 P_("Tree line pattern"),
1268                                                                 P_("Dash pattern used to draw the tree view lines"),
1269                                                                 "\1\1",
1270                                                                 GTK_PARAM_READABLE));
1271
1272   /* Signals */
1273   /**
1274    * GtkTreeView::row-activated:
1275    * @tree_view: the object on which the signal is emitted
1276    * @path: the #GtkTreePath for the activated row
1277    * @column: the #GtkTreeViewColumn in which the activation occurred
1278    *
1279    * The "row-activated" signal is emitted when the method
1280    * gtk_tree_view_row_activated() is called or the user double clicks
1281    * a treeview row. It is also emitted when a non-editable row is
1282    * selected and one of the keys: Space, Shift+Space, Return or
1283    * Enter is pressed.
1284    *
1285    * For selection handling refer to the <link linkend="TreeWidget">tree
1286    * widget conceptual overview</link> as well as #GtkTreeSelection.
1287    */
1288   tree_view_signals[ROW_ACTIVATED] =
1289     g_signal_new (I_("row-activated"),
1290                   G_TYPE_FROM_CLASS (o_class),
1291                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1292                   G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
1293                   NULL, NULL,
1294                   _gtk_marshal_VOID__BOXED_OBJECT,
1295                   G_TYPE_NONE, 2,
1296                   GTK_TYPE_TREE_PATH,
1297                   GTK_TYPE_TREE_VIEW_COLUMN);
1298
1299   /**
1300    * GtkTreeView::test-expand-row:
1301    * @tree_view: the object on which the signal is emitted
1302    * @iter: the tree iter of the row to expand
1303    * @path: a tree path that points to the row
1304    *
1305    * The given row is about to be expanded (show its children nodes). Use this
1306    * signal if you need to control the expandability of individual rows.
1307    *
1308    * Returns: %FALSE to allow expansion, %TRUE to reject
1309    */
1310   tree_view_signals[TEST_EXPAND_ROW] =
1311     g_signal_new (I_("test-expand-row"),
1312                   G_TYPE_FROM_CLASS (o_class),
1313                   G_SIGNAL_RUN_LAST,
1314                   G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
1315                   _gtk_boolean_handled_accumulator, NULL,
1316                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1317                   G_TYPE_BOOLEAN, 2,
1318                   GTK_TYPE_TREE_ITER,
1319                   GTK_TYPE_TREE_PATH);
1320
1321   /**
1322    * GtkTreeView::test-collapse-row:
1323    * @tree_view: the object on which the signal is emitted
1324    * @iter: the tree iter of the row to collapse
1325    * @path: a tree path that points to the row
1326    *
1327    * The given row is about to be collapsed (hide its children nodes). Use this
1328    * signal if you need to control the collapsibility of individual rows.
1329    *
1330    * Returns: %FALSE to allow collapsing, %TRUE to reject
1331    */
1332   tree_view_signals[TEST_COLLAPSE_ROW] =
1333     g_signal_new (I_("test-collapse-row"),
1334                   G_TYPE_FROM_CLASS (o_class),
1335                   G_SIGNAL_RUN_LAST,
1336                   G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
1337                   _gtk_boolean_handled_accumulator, NULL,
1338                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1339                   G_TYPE_BOOLEAN, 2,
1340                   GTK_TYPE_TREE_ITER,
1341                   GTK_TYPE_TREE_PATH);
1342
1343   /**
1344    * GtkTreeView::row-expanded:
1345    * @tree_view: the object on which the signal is emitted
1346    * @iter: the tree iter of the expanded row
1347    * @path: a tree path that points to the row
1348    *
1349    * The given row has been expanded (child nodes are shown).
1350    */
1351   tree_view_signals[ROW_EXPANDED] =
1352     g_signal_new (I_("row-expanded"),
1353                   G_TYPE_FROM_CLASS (o_class),
1354                   G_SIGNAL_RUN_LAST,
1355                   G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
1356                   NULL, NULL,
1357                   _gtk_marshal_VOID__BOXED_BOXED,
1358                   G_TYPE_NONE, 2,
1359                   GTK_TYPE_TREE_ITER,
1360                   GTK_TYPE_TREE_PATH);
1361
1362   /**
1363    * GtkTreeView::row-collapsed:
1364    * @tree_view: the object on which the signal is emitted
1365    * @iter: the tree iter of the collapsed row
1366    * @path: a tree path that points to the row
1367    *
1368    * The given row has been collapsed (child nodes are hidden).
1369    */
1370   tree_view_signals[ROW_COLLAPSED] =
1371     g_signal_new (I_("row-collapsed"),
1372                   G_TYPE_FROM_CLASS (o_class),
1373                   G_SIGNAL_RUN_LAST,
1374                   G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
1375                   NULL, NULL,
1376                   _gtk_marshal_VOID__BOXED_BOXED,
1377                   G_TYPE_NONE, 2,
1378                   GTK_TYPE_TREE_ITER,
1379                   GTK_TYPE_TREE_PATH);
1380
1381   /**
1382    * GtkTreeView::columns-changed:
1383    * @tree_view: the object on which the signal is emitted
1384    *
1385    * The number of columns of the treeview has changed.
1386    */
1387   tree_view_signals[COLUMNS_CHANGED] =
1388     g_signal_new (I_("columns-changed"),
1389                   G_TYPE_FROM_CLASS (o_class),
1390                   G_SIGNAL_RUN_LAST,
1391                   G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
1392                   NULL, NULL,
1393                   _gtk_marshal_VOID__VOID,
1394                   G_TYPE_NONE, 0);
1395
1396   /**
1397    * GtkTreeView::cursor-changed:
1398    * @tree_view: the object on which the signal is emitted
1399    *
1400    * The position of the cursor (focused cell) has changed.
1401    */
1402   tree_view_signals[CURSOR_CHANGED] =
1403     g_signal_new (I_("cursor-changed"),
1404                   G_TYPE_FROM_CLASS (o_class),
1405                   G_SIGNAL_RUN_LAST,
1406                   G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
1407                   NULL, NULL,
1408                   _gtk_marshal_VOID__VOID,
1409                   G_TYPE_NONE, 0);
1410
1411   tree_view_signals[MOVE_CURSOR] =
1412     g_signal_new (I_("move-cursor"),
1413                   G_TYPE_FROM_CLASS (o_class),
1414                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1415                   G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
1416                   NULL, NULL,
1417                   _gtk_marshal_BOOLEAN__ENUM_INT,
1418                   G_TYPE_BOOLEAN, 2,
1419                   GTK_TYPE_MOVEMENT_STEP,
1420                   G_TYPE_INT);
1421
1422   tree_view_signals[SELECT_ALL] =
1423     g_signal_new (I_("select-all"),
1424                   G_TYPE_FROM_CLASS (o_class),
1425                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1426                   G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
1427                   NULL, NULL,
1428                   _gtk_marshal_BOOLEAN__VOID,
1429                   G_TYPE_BOOLEAN, 0);
1430
1431   tree_view_signals[UNSELECT_ALL] =
1432     g_signal_new (I_("unselect-all"),
1433                   G_TYPE_FROM_CLASS (o_class),
1434                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1435                   G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
1436                   NULL, NULL,
1437                   _gtk_marshal_BOOLEAN__VOID,
1438                   G_TYPE_BOOLEAN, 0);
1439
1440   tree_view_signals[SELECT_CURSOR_ROW] =
1441     g_signal_new (I_("select-cursor-row"),
1442                   G_TYPE_FROM_CLASS (o_class),
1443                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1444                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
1445                   NULL, NULL,
1446                   _gtk_marshal_BOOLEAN__BOOLEAN,
1447                   G_TYPE_BOOLEAN, 1,
1448                   G_TYPE_BOOLEAN);
1449
1450   tree_view_signals[TOGGLE_CURSOR_ROW] =
1451     g_signal_new (I_("toggle-cursor-row"),
1452                   G_TYPE_FROM_CLASS (o_class),
1453                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1454                   G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
1455                   NULL, NULL,
1456                   _gtk_marshal_BOOLEAN__VOID,
1457                   G_TYPE_BOOLEAN, 0);
1458
1459   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
1460     g_signal_new (I_("expand-collapse-cursor-row"),
1461                   G_TYPE_FROM_CLASS (o_class),
1462                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1463                   G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
1464                   NULL, NULL,
1465                   _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
1466                   G_TYPE_BOOLEAN, 3,
1467                   G_TYPE_BOOLEAN,
1468                   G_TYPE_BOOLEAN,
1469                   G_TYPE_BOOLEAN);
1470
1471   tree_view_signals[SELECT_CURSOR_PARENT] =
1472     g_signal_new (I_("select-cursor-parent"),
1473                   G_TYPE_FROM_CLASS (o_class),
1474                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1475                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
1476                   NULL, NULL,
1477                   _gtk_marshal_BOOLEAN__VOID,
1478                   G_TYPE_BOOLEAN, 0);
1479
1480   tree_view_signals[START_INTERACTIVE_SEARCH] =
1481     g_signal_new (I_("start-interactive-search"),
1482                   G_TYPE_FROM_CLASS (o_class),
1483                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1484                   G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
1485                   NULL, NULL,
1486                   _gtk_marshal_BOOLEAN__VOID,
1487                   G_TYPE_BOOLEAN, 0);
1488
1489   /* Key bindings */
1490   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Up, 0, TRUE,
1491                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1492   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Up, 0, TRUE,
1493                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1494
1495   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Down, 0, TRUE,
1496                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1497   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Down, 0, TRUE,
1498                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1499
1500   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_p, GDK_CONTROL_MASK, FALSE,
1501                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1502
1503   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_n, GDK_CONTROL_MASK, FALSE,
1504                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1505
1506   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Home, 0, TRUE,
1507                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1508   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Home, 0, TRUE,
1509                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1510
1511   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_End, 0, TRUE,
1512                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1513   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_End, 0, TRUE,
1514                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1515
1516   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Up, 0, TRUE,
1517                                   GTK_MOVEMENT_PAGES, -1);
1518   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0, TRUE,
1519                                   GTK_MOVEMENT_PAGES, -1);
1520
1521   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Down, 0, TRUE,
1522                                   GTK_MOVEMENT_PAGES, 1);
1523   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0, TRUE,
1524                                   GTK_MOVEMENT_PAGES, 1);
1525
1526
1527   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 0, "move-cursor", 2,
1528                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1529                                 G_TYPE_INT, 1);
1530
1531   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 0, "move-cursor", 2,
1532                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1533                                 G_TYPE_INT, -1);
1534
1535   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, 0, "move-cursor", 2,
1536                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1537                                 G_TYPE_INT, 1);
1538
1539   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, 0, "move-cursor", 2,
1540                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1541                                 G_TYPE_INT, -1);
1542
1543   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK,
1544                                 "move-cursor", 2,
1545                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1546                                 G_TYPE_INT, 1);
1547
1548   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
1549                                 "move-cursor", 2,
1550                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1551                                 G_TYPE_INT, -1);
1552
1553   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK,
1554                                 "move-cursor", 2,
1555                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1556                                 G_TYPE_INT, 1);
1557
1558   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
1559                                 "move-cursor", 2,
1560                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1561                                 G_TYPE_INT, -1);
1562
1563   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1564   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1565
1566   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK, "select-all", 0);
1567   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK, "select-all", 0);
1568
1569   gtk_binding_entry_add_signal (binding_set, GDK_KEY_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1570   gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1571
1572   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1573                                 G_TYPE_BOOLEAN, TRUE);
1574   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1575                                 G_TYPE_BOOLEAN, TRUE);
1576
1577   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0, "select-cursor-row", 1,
1578                                 G_TYPE_BOOLEAN, TRUE);
1579   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0, "select-cursor-row", 1,
1580                                 G_TYPE_BOOLEAN, TRUE);
1581   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0, "select-cursor-row", 1,
1582                                 G_TYPE_BOOLEAN, TRUE);
1583   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0, "select-cursor-row", 1,
1584                                 G_TYPE_BOOLEAN, TRUE);
1585   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0, "select-cursor-row", 1,
1586                                 G_TYPE_BOOLEAN, TRUE);
1587
1588   /* expand and collapse rows */
1589   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, 0, "expand-collapse-cursor-row", 3,
1590                                 G_TYPE_BOOLEAN, TRUE,
1591                                 G_TYPE_BOOLEAN, TRUE,
1592                                 G_TYPE_BOOLEAN, FALSE);
1593
1594   gtk_binding_entry_add_signal (binding_set, GDK_KEY_asterisk, 0,
1595                                 "expand-collapse-cursor-row", 3,
1596                                 G_TYPE_BOOLEAN, TRUE,
1597                                 G_TYPE_BOOLEAN, TRUE,
1598                                 G_TYPE_BOOLEAN, TRUE);
1599   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Multiply, 0,
1600                                 "expand-collapse-cursor-row", 3,
1601                                 G_TYPE_BOOLEAN, TRUE,
1602                                 G_TYPE_BOOLEAN, TRUE,
1603                                 G_TYPE_BOOLEAN, TRUE);
1604
1605   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, 0,
1606                                 "expand-collapse-cursor-row", 3,
1607                                 G_TYPE_BOOLEAN, TRUE,
1608                                 G_TYPE_BOOLEAN, FALSE,
1609                                 G_TYPE_BOOLEAN, FALSE);
1610   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Divide, 0,
1611                                 "expand-collapse-cursor-row", 3,
1612                                 G_TYPE_BOOLEAN, TRUE,
1613                                 G_TYPE_BOOLEAN, FALSE,
1614                                 G_TYPE_BOOLEAN, FALSE);
1615
1616   /* Not doable on US keyboards */
1617   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1618                                 G_TYPE_BOOLEAN, TRUE,
1619                                 G_TYPE_BOOLEAN, TRUE,
1620                                 G_TYPE_BOOLEAN, TRUE);
1621   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, 0, "expand-collapse-cursor-row", 3,
1622                                 G_TYPE_BOOLEAN, TRUE,
1623                                 G_TYPE_BOOLEAN, TRUE,
1624                                 G_TYPE_BOOLEAN, FALSE);
1625   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1626                                 G_TYPE_BOOLEAN, TRUE,
1627                                 G_TYPE_BOOLEAN, TRUE,
1628                                 G_TYPE_BOOLEAN, TRUE);
1629   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1630                                 G_TYPE_BOOLEAN, TRUE,
1631                                 G_TYPE_BOOLEAN, TRUE,
1632                                 G_TYPE_BOOLEAN, TRUE);
1633   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_SHIFT_MASK,
1634                                 "expand-collapse-cursor-row", 3,
1635                                 G_TYPE_BOOLEAN, FALSE,
1636                                 G_TYPE_BOOLEAN, TRUE,
1637                                 G_TYPE_BOOLEAN, TRUE);
1638   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_SHIFT_MASK,
1639                                 "expand-collapse-cursor-row", 3,
1640                                 G_TYPE_BOOLEAN, FALSE,
1641                                 G_TYPE_BOOLEAN, TRUE,
1642                                 G_TYPE_BOOLEAN, TRUE);
1643   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right,
1644                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1645                                 "expand-collapse-cursor-row", 3,
1646                                 G_TYPE_BOOLEAN, FALSE,
1647                                 G_TYPE_BOOLEAN, TRUE,
1648                                 G_TYPE_BOOLEAN, TRUE);
1649   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right,
1650                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1651                                 "expand-collapse-cursor-row", 3,
1652                                 G_TYPE_BOOLEAN, FALSE,
1653                                 G_TYPE_BOOLEAN, TRUE,
1654                                 G_TYPE_BOOLEAN, TRUE);
1655
1656   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, 0, "expand-collapse-cursor-row", 3,
1657                                 G_TYPE_BOOLEAN, TRUE,
1658                                 G_TYPE_BOOLEAN, FALSE,
1659                                 G_TYPE_BOOLEAN, FALSE);
1660   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1661                                 G_TYPE_BOOLEAN, TRUE,
1662                                 G_TYPE_BOOLEAN, FALSE,
1663                                 G_TYPE_BOOLEAN, TRUE);
1664   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, 0, "expand-collapse-cursor-row", 3,
1665                                 G_TYPE_BOOLEAN, TRUE,
1666                                 G_TYPE_BOOLEAN, FALSE,
1667                                 G_TYPE_BOOLEAN, FALSE);
1668   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1669                                 G_TYPE_BOOLEAN, TRUE,
1670                                 G_TYPE_BOOLEAN, FALSE,
1671                                 G_TYPE_BOOLEAN, TRUE);
1672   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_SHIFT_MASK,
1673                                 "expand-collapse-cursor-row", 3,
1674                                 G_TYPE_BOOLEAN, FALSE,
1675                                 G_TYPE_BOOLEAN, FALSE,
1676                                 G_TYPE_BOOLEAN, TRUE);
1677   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_SHIFT_MASK,
1678                                 "expand-collapse-cursor-row", 3,
1679                                 G_TYPE_BOOLEAN, FALSE,
1680                                 G_TYPE_BOOLEAN, FALSE,
1681                                 G_TYPE_BOOLEAN, TRUE);
1682   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left,
1683                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1684                                 "expand-collapse-cursor-row", 3,
1685                                 G_TYPE_BOOLEAN, FALSE,
1686                                 G_TYPE_BOOLEAN, FALSE,
1687                                 G_TYPE_BOOLEAN, TRUE);
1688   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left,
1689                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1690                                 "expand-collapse-cursor-row", 3,
1691                                 G_TYPE_BOOLEAN, FALSE,
1692                                 G_TYPE_BOOLEAN, FALSE,
1693                                 G_TYPE_BOOLEAN, TRUE);
1694
1695   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, 0, "select-cursor-parent", 0);
1696   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1697
1698   gtk_binding_entry_add_signal (binding_set, GDK_KEY_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1699
1700   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1701
1702   g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
1703
1704   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TREE_VIEW_ACCESSIBLE);
1705 }
1706
1707 static void
1708 gtk_tree_view_init (GtkTreeView *tree_view)
1709 {
1710   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
1711
1712   gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
1713   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1714
1715   tree_view->priv->show_expanders = TRUE;
1716   tree_view->priv->draw_keyfocus = TRUE;
1717   tree_view->priv->headers_visible = TRUE;
1718
1719   /* We need some padding */
1720   tree_view->priv->dy = 0;
1721   tree_view->priv->cursor_offset = 0;
1722   tree_view->priv->n_columns = 0;
1723   tree_view->priv->header_height = 1;
1724   tree_view->priv->x_drag = 0;
1725   tree_view->priv->drag_pos = -1;
1726   tree_view->priv->header_has_focus = FALSE;
1727   tree_view->priv->pressed_button = -1;
1728   tree_view->priv->press_start_x = -1;
1729   tree_view->priv->press_start_y = -1;
1730   tree_view->priv->reorderable = FALSE;
1731   tree_view->priv->presize_handler_timer = 0;
1732   tree_view->priv->scroll_sync_timer = 0;
1733   tree_view->priv->fixed_height = -1;
1734   tree_view->priv->fixed_height_mode = FALSE;
1735   tree_view->priv->fixed_height_check = 0;
1736   tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
1737   tree_view->priv->enable_search = TRUE;
1738   tree_view->priv->search_column = -1;
1739   tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
1740   tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
1741   tree_view->priv->search_custom_entry_set = FALSE;
1742   tree_view->priv->typeselect_flush_timeout = 0;
1743   tree_view->priv->init_hadjust_value = TRUE;
1744   tree_view->priv->width = 0;
1745
1746   tree_view->priv->hover_selection = FALSE;
1747   tree_view->priv->hover_expand = FALSE;
1748
1749   tree_view->priv->level_indentation = 0;
1750
1751   tree_view->priv->rubber_banding_enable = FALSE;
1752
1753   tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
1754   tree_view->priv->tree_lines_enabled = FALSE;
1755
1756   tree_view->priv->tooltip_column = -1;
1757
1758   tree_view->priv->post_validation_flag = FALSE;
1759
1760   tree_view->priv->last_button_x = -1;
1761   tree_view->priv->last_button_y = -1;
1762
1763   tree_view->priv->event_last_x = -10000;
1764   tree_view->priv->event_last_y = -10000;
1765
1766   gtk_tree_view_do_set_vadjustment (tree_view, NULL);
1767   gtk_tree_view_do_set_hadjustment (tree_view, NULL);
1768 }
1769
1770 \f
1771
1772 /* GObject Methods
1773  */
1774
1775 static void
1776 gtk_tree_view_set_property (GObject         *object,
1777                             guint            prop_id,
1778                             const GValue    *value,
1779                             GParamSpec      *pspec)
1780 {
1781   GtkTreeView *tree_view;
1782
1783   tree_view = GTK_TREE_VIEW (object);
1784
1785   switch (prop_id)
1786     {
1787     case PROP_MODEL:
1788       gtk_tree_view_set_model (tree_view, g_value_get_object (value));
1789       break;
1790     case PROP_HADJUSTMENT:
1791       gtk_tree_view_do_set_hadjustment (tree_view, g_value_get_object (value));
1792       break;
1793     case PROP_VADJUSTMENT:
1794       gtk_tree_view_do_set_vadjustment (tree_view, g_value_get_object (value));
1795       break;
1796     case PROP_HSCROLL_POLICY:
1797       tree_view->priv->hscroll_policy = g_value_get_enum (value);
1798       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1799       break;
1800     case PROP_VSCROLL_POLICY:
1801       tree_view->priv->vscroll_policy = g_value_get_enum (value);
1802       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1803       break;
1804     case PROP_HEADERS_VISIBLE:
1805       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1806       break;
1807     case PROP_HEADERS_CLICKABLE:
1808       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1809       break;
1810     case PROP_EXPANDER_COLUMN:
1811       gtk_tree_view_set_expander_column (tree_view, g_value_get_object (value));
1812       break;
1813     case PROP_REORDERABLE:
1814       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
1815       break;
1816     case PROP_RULES_HINT:
1817       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1818       break;
1819     case PROP_ENABLE_SEARCH:
1820       gtk_tree_view_set_enable_search (tree_view, g_value_get_boolean (value));
1821       break;
1822     case PROP_SEARCH_COLUMN:
1823       gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
1824       break;
1825     case PROP_FIXED_HEIGHT_MODE:
1826       gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
1827       break;
1828     case PROP_HOVER_SELECTION:
1829       tree_view->priv->hover_selection = g_value_get_boolean (value);
1830       break;
1831     case PROP_HOVER_EXPAND:
1832       tree_view->priv->hover_expand = g_value_get_boolean (value);
1833       break;
1834     case PROP_SHOW_EXPANDERS:
1835       gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
1836       break;
1837     case PROP_LEVEL_INDENTATION:
1838       tree_view->priv->level_indentation = g_value_get_int (value);
1839       break;
1840     case PROP_RUBBER_BANDING:
1841       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1842       break;
1843     case PROP_ENABLE_GRID_LINES:
1844       gtk_tree_view_set_grid_lines (tree_view, g_value_get_enum (value));
1845       break;
1846     case PROP_ENABLE_TREE_LINES:
1847       gtk_tree_view_set_enable_tree_lines (tree_view, g_value_get_boolean (value));
1848       break;
1849     case PROP_TOOLTIP_COLUMN:
1850       gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
1851       break;
1852     default:
1853       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1854       break;
1855     }
1856 }
1857
1858 static void
1859 gtk_tree_view_get_property (GObject    *object,
1860                             guint       prop_id,
1861                             GValue     *value,
1862                             GParamSpec *pspec)
1863 {
1864   GtkTreeView *tree_view;
1865
1866   tree_view = GTK_TREE_VIEW (object);
1867
1868   switch (prop_id)
1869     {
1870     case PROP_MODEL:
1871       g_value_set_object (value, tree_view->priv->model);
1872       break;
1873     case PROP_HADJUSTMENT:
1874       g_value_set_object (value, tree_view->priv->hadjustment);
1875       break;
1876     case PROP_VADJUSTMENT:
1877       g_value_set_object (value, tree_view->priv->vadjustment);
1878       break;
1879     case PROP_HSCROLL_POLICY:
1880       g_value_set_enum (value, tree_view->priv->hscroll_policy);
1881       break;
1882     case PROP_VSCROLL_POLICY:
1883       g_value_set_enum (value, tree_view->priv->vscroll_policy);
1884       break;
1885     case PROP_HEADERS_VISIBLE:
1886       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
1887       break;
1888     case PROP_HEADERS_CLICKABLE:
1889       g_value_set_boolean (value, gtk_tree_view_get_headers_clickable (tree_view));
1890       break;
1891     case PROP_EXPANDER_COLUMN:
1892       g_value_set_object (value, tree_view->priv->expander_column);
1893       break;
1894     case PROP_REORDERABLE:
1895       g_value_set_boolean (value, tree_view->priv->reorderable);
1896       break;
1897     case PROP_RULES_HINT:
1898       g_value_set_boolean (value, tree_view->priv->has_rules);
1899       break;
1900     case PROP_ENABLE_SEARCH:
1901       g_value_set_boolean (value, tree_view->priv->enable_search);
1902       break;
1903     case PROP_SEARCH_COLUMN:
1904       g_value_set_int (value, tree_view->priv->search_column);
1905       break;
1906     case PROP_FIXED_HEIGHT_MODE:
1907       g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
1908       break;
1909     case PROP_HOVER_SELECTION:
1910       g_value_set_boolean (value, tree_view->priv->hover_selection);
1911       break;
1912     case PROP_HOVER_EXPAND:
1913       g_value_set_boolean (value, tree_view->priv->hover_expand);
1914       break;
1915     case PROP_SHOW_EXPANDERS:
1916       g_value_set_boolean (value, tree_view->priv->show_expanders);
1917       break;
1918     case PROP_LEVEL_INDENTATION:
1919       g_value_set_int (value, tree_view->priv->level_indentation);
1920       break;
1921     case PROP_RUBBER_BANDING:
1922       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1923       break;
1924     case PROP_ENABLE_GRID_LINES:
1925       g_value_set_enum (value, tree_view->priv->grid_lines);
1926       break;
1927     case PROP_ENABLE_TREE_LINES:
1928       g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
1929       break;
1930     case PROP_TOOLTIP_COLUMN:
1931       g_value_set_int (value, tree_view->priv->tooltip_column);
1932       break;
1933     default:
1934       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1935       break;
1936     }
1937 }
1938
1939 static void
1940 gtk_tree_view_finalize (GObject *object)
1941 {
1942   G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
1943 }
1944
1945
1946 static GtkBuildableIface *parent_buildable_iface;
1947
1948 static void
1949 gtk_tree_view_buildable_init (GtkBuildableIface *iface)
1950 {
1951   parent_buildable_iface = g_type_interface_peek_parent (iface);
1952   iface->add_child = gtk_tree_view_buildable_add_child;
1953   iface->get_internal_child = gtk_tree_view_buildable_get_internal_child;
1954 }
1955
1956 static void
1957 gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
1958                                    GtkBuilder  *builder,
1959                                    GObject     *child,
1960                                    const gchar *type)
1961 {
1962   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (child));
1963 }
1964
1965 static GObject *
1966 gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
1967                                             GtkBuilder        *builder,
1968                                             const gchar       *childname)
1969 {
1970     if (strcmp (childname, "selection") == 0)
1971       return G_OBJECT (GTK_TREE_VIEW (buildable)->priv->selection);
1972
1973     return parent_buildable_iface->get_internal_child (buildable,
1974                                                        builder,
1975                                                        childname);
1976 }
1977
1978 /* GtkWidget Methods
1979  */
1980
1981 static void
1982 gtk_tree_view_free_rbtree (GtkTreeView *tree_view)
1983 {
1984   _gtk_rbtree_free (tree_view->priv->tree);
1985
1986   tree_view->priv->tree = NULL;
1987   tree_view->priv->button_pressed_node = NULL;
1988   tree_view->priv->button_pressed_tree = NULL;
1989   tree_view->priv->prelight_tree = NULL;
1990   tree_view->priv->prelight_node = NULL;
1991   tree_view->priv->expanded_collapsed_node = NULL;
1992   tree_view->priv->expanded_collapsed_tree = NULL;
1993 }
1994
1995 static void
1996 gtk_tree_view_destroy (GtkWidget *widget)
1997 {
1998   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1999   GList *list;
2000
2001   gtk_tree_view_stop_editing (tree_view, TRUE);
2002
2003   if (tree_view->priv->columns != NULL)
2004     {
2005       list = tree_view->priv->columns;
2006       while (list)
2007         {
2008           GtkTreeViewColumn *column;
2009           column = GTK_TREE_VIEW_COLUMN (list->data);
2010           list = list->next;
2011           gtk_tree_view_remove_column (tree_view, column);
2012         }
2013       tree_view->priv->columns = NULL;
2014     }
2015
2016   if (tree_view->priv->tree != NULL)
2017     {
2018       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
2019
2020       gtk_tree_view_free_rbtree (tree_view);
2021     }
2022
2023   if (tree_view->priv->selection != NULL)
2024     {
2025       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
2026       g_object_unref (tree_view->priv->selection);
2027       tree_view->priv->selection = NULL;
2028     }
2029
2030   if (tree_view->priv->scroll_to_path != NULL)
2031     {
2032       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
2033       tree_view->priv->scroll_to_path = NULL;
2034     }
2035
2036   if (tree_view->priv->drag_dest_row != NULL)
2037     {
2038       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
2039       tree_view->priv->drag_dest_row = NULL;
2040     }
2041
2042   if (tree_view->priv->top_row != NULL)
2043     {
2044       gtk_tree_row_reference_free (tree_view->priv->top_row);
2045       tree_view->priv->top_row = NULL;
2046     }
2047
2048   if (tree_view->priv->column_drop_func_data &&
2049       tree_view->priv->column_drop_func_data_destroy)
2050     {
2051       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
2052       tree_view->priv->column_drop_func_data = NULL;
2053     }
2054
2055   if (tree_view->priv->destroy_count_destroy &&
2056       tree_view->priv->destroy_count_data)
2057     {
2058       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
2059       tree_view->priv->destroy_count_data = NULL;
2060     }
2061
2062   gtk_tree_row_reference_free (tree_view->priv->anchor);
2063   tree_view->priv->anchor = NULL;
2064
2065   /* destroy interactive search dialog */
2066   if (tree_view->priv->search_window)
2067     {
2068       gtk_widget_destroy (tree_view->priv->search_window);
2069       tree_view->priv->search_window = NULL;
2070       tree_view->priv->search_entry = NULL;
2071       if (tree_view->priv->typeselect_flush_timeout)
2072         {
2073           g_source_remove (tree_view->priv->typeselect_flush_timeout);
2074           tree_view->priv->typeselect_flush_timeout = 0;
2075         }
2076     }
2077
2078   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
2079     {
2080       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
2081       tree_view->priv->search_user_data = NULL;
2082     }
2083
2084   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
2085     {
2086       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
2087       tree_view->priv->search_position_user_data = NULL;
2088     }
2089
2090   if (tree_view->priv->row_separator_destroy && tree_view->priv->row_separator_data)
2091     {
2092       tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
2093       tree_view->priv->row_separator_data = NULL;
2094     }
2095
2096   gtk_tree_view_set_model (tree_view, NULL);
2097
2098   if (tree_view->priv->hadjustment)
2099     {
2100       g_object_unref (tree_view->priv->hadjustment);
2101       tree_view->priv->hadjustment = NULL;
2102     }
2103   if (tree_view->priv->vadjustment)
2104     {
2105       g_object_unref (tree_view->priv->vadjustment);
2106       tree_view->priv->vadjustment = NULL;
2107     }
2108
2109   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->destroy (widget);
2110 }
2111
2112 /* GtkWidget::map helper */
2113 static void
2114 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
2115 {
2116   GList *list;
2117
2118   g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
2119
2120   if (tree_view->priv->headers_visible)
2121     {
2122       GtkTreeViewColumn *column;
2123       GtkWidget         *button;
2124       GdkWindow         *window;
2125
2126       for (list = tree_view->priv->columns; list; list = list->next)
2127         {
2128           column = list->data;
2129           button = gtk_tree_view_column_get_button (column);
2130
2131           if (gtk_tree_view_column_get_visible (column) && button)
2132             gtk_widget_show_now (button);
2133
2134           if (gtk_widget_get_visible (button) &&
2135               !gtk_widget_get_mapped (button))
2136             gtk_widget_map (button);
2137         }
2138       for (list = tree_view->priv->columns; list; list = list->next)
2139         {
2140           column = list->data;
2141           if (gtk_tree_view_column_get_visible (column) == FALSE)
2142             continue;
2143
2144           window = _gtk_tree_view_column_get_window (column);
2145           if (gtk_tree_view_column_get_resizable (column))
2146             {
2147               gdk_window_raise (window);
2148               gdk_window_show (window);
2149             }
2150           else
2151             gdk_window_hide (window);
2152         }
2153       gdk_window_show (tree_view->priv->header_window);
2154     }
2155 }
2156
2157 static void
2158 gtk_tree_view_map (GtkWidget *widget)
2159 {
2160   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2161   GList *tmp_list;
2162
2163   gtk_widget_set_mapped (widget, TRUE);
2164
2165   tmp_list = tree_view->priv->children;
2166   while (tmp_list)
2167     {
2168       GtkTreeViewChild *child = tmp_list->data;
2169       tmp_list = tmp_list->next;
2170
2171       if (gtk_widget_get_visible (child->widget))
2172         {
2173           if (!gtk_widget_get_mapped (child->widget))
2174             gtk_widget_map (child->widget);
2175         }
2176     }
2177   gdk_window_show (tree_view->priv->bin_window);
2178
2179   gtk_tree_view_map_buttons (tree_view);
2180
2181   gdk_window_show (gtk_widget_get_window (widget));
2182 }
2183
2184 static void
2185 gtk_tree_view_ensure_background (GtkTreeView *tree_view)
2186 {
2187   GtkStyleContext *context;
2188
2189   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
2190
2191   gtk_style_context_save (context);
2192   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
2193   gtk_style_context_set_background (context, tree_view->priv->bin_window);
2194   gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view)));
2195   gtk_style_context_restore (context);
2196
2197   gtk_style_context_set_background (context, tree_view->priv->header_window);
2198 }
2199
2200 static void
2201 gtk_tree_view_realize (GtkWidget *widget)
2202 {
2203   GtkAllocation allocation;
2204   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2205   GdkWindow *window;
2206   GdkWindowAttr attributes;
2207   GList *tmp_list;
2208   gint attributes_mask;
2209
2210   gtk_widget_set_realized (widget, TRUE);
2211
2212   gtk_widget_get_allocation (widget, &allocation);
2213
2214   /* Make the main, clipping window */
2215   attributes.window_type = GDK_WINDOW_CHILD;
2216   attributes.x = allocation.x;
2217   attributes.y = allocation.y;
2218   attributes.width = allocation.width;
2219   attributes.height = allocation.height;
2220   attributes.wclass = GDK_INPUT_OUTPUT;
2221   attributes.visual = gtk_widget_get_visual (widget);
2222   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
2223
2224   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
2225
2226   window = gdk_window_new (gtk_widget_get_parent_window (widget),
2227                            &attributes, attributes_mask);
2228   gtk_widget_set_window (widget, window);
2229   gdk_window_set_user_data (window, widget);
2230
2231   gtk_widget_get_allocation (widget, &allocation);
2232
2233   /* Make the window for the tree */
2234   attributes.x = 0;
2235   attributes.y = gtk_tree_view_get_effective_header_height (tree_view);
2236   attributes.width = MAX (tree_view->priv->width, allocation.width);
2237   attributes.height = allocation.height;
2238   attributes.event_mask = (GDK_EXPOSURE_MASK |
2239                            GDK_SCROLL_MASK |
2240                            GDK_SMOOTH_SCROLL_MASK |
2241                            GDK_POINTER_MOTION_MASK |
2242                            GDK_ENTER_NOTIFY_MASK |
2243                            GDK_LEAVE_NOTIFY_MASK |
2244                            GDK_BUTTON_PRESS_MASK |
2245                            GDK_BUTTON_RELEASE_MASK |
2246                            gtk_widget_get_events (widget));
2247
2248   tree_view->priv->bin_window = gdk_window_new (window,
2249                                                 &attributes, attributes_mask);
2250   gdk_window_set_user_data (tree_view->priv->bin_window, widget);
2251
2252   gtk_widget_get_allocation (widget, &allocation);
2253
2254   /* Make the column header window */
2255   attributes.x = 0;
2256   attributes.y = 0;
2257   attributes.width = MAX (tree_view->priv->width, allocation.width);
2258   attributes.height = tree_view->priv->header_height;
2259   attributes.event_mask = (GDK_EXPOSURE_MASK |
2260                            GDK_SCROLL_MASK |
2261                            GDK_ENTER_NOTIFY_MASK |
2262                            GDK_LEAVE_NOTIFY_MASK |
2263                            GDK_BUTTON_PRESS_MASK |
2264                            GDK_BUTTON_RELEASE_MASK |
2265                            GDK_KEY_PRESS_MASK |
2266                            GDK_KEY_RELEASE_MASK |
2267                            gtk_widget_get_events (widget));
2268
2269   tree_view->priv->header_window = gdk_window_new (window,
2270                                                    &attributes, attributes_mask);
2271   gdk_window_set_user_data (tree_view->priv->header_window, widget);
2272
2273   gtk_tree_view_ensure_background (tree_view);
2274
2275   tmp_list = tree_view->priv->children;
2276   while (tmp_list)
2277     {
2278       GtkTreeViewChild *child = tmp_list->data;
2279       tmp_list = tmp_list->next;
2280
2281       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
2282     }
2283
2284   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2285     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
2286
2287   /* Need to call those here, since they create GCs */
2288   gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
2289   gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
2290
2291   install_presize_handler (tree_view);
2292 }
2293
2294 static void
2295 gtk_tree_view_unrealize (GtkWidget *widget)
2296 {
2297   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2298   GtkTreeViewPrivate *priv = tree_view->priv;
2299   GtkStyleContext *context;
2300   GList *list;
2301
2302   if (priv->scroll_timeout != 0)
2303     {
2304       g_source_remove (priv->scroll_timeout);
2305       priv->scroll_timeout = 0;
2306     }
2307
2308   if (priv->auto_expand_timeout != 0)
2309     {
2310       g_source_remove (priv->auto_expand_timeout);
2311       priv->auto_expand_timeout = 0;
2312     }
2313
2314   if (priv->open_dest_timeout != 0)
2315     {
2316       g_source_remove (priv->open_dest_timeout);
2317       priv->open_dest_timeout = 0;
2318     }
2319
2320   context = gtk_widget_get_style_context (widget);
2321   gtk_style_context_cancel_animations (context, NULL);
2322
2323   if (priv->presize_handler_timer != 0)
2324     {
2325       g_source_remove (priv->presize_handler_timer);
2326       priv->presize_handler_timer = 0;
2327     }
2328
2329   if (priv->validate_rows_timer != 0)
2330     {
2331       g_source_remove (priv->validate_rows_timer);
2332       priv->validate_rows_timer = 0;
2333     }
2334
2335   if (priv->scroll_sync_timer != 0)
2336     {
2337       g_source_remove (priv->scroll_sync_timer);
2338       priv->scroll_sync_timer = 0;
2339     }
2340
2341   if (priv->typeselect_flush_timeout)
2342     {
2343       g_source_remove (priv->typeselect_flush_timeout);
2344       priv->typeselect_flush_timeout = 0;
2345     }
2346
2347   for (list = priv->columns; list; list = list->next)
2348     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
2349
2350   gdk_window_set_user_data (priv->bin_window, NULL);
2351   gdk_window_destroy (priv->bin_window);
2352   priv->bin_window = NULL;
2353
2354   gdk_window_set_user_data (priv->header_window, NULL);
2355   gdk_window_destroy (priv->header_window);
2356   priv->header_window = NULL;
2357
2358   if (priv->drag_window)
2359     {
2360       gdk_window_set_user_data (priv->drag_window, NULL);
2361       gdk_window_destroy (priv->drag_window);
2362       priv->drag_window = NULL;
2363     }
2364
2365   if (priv->drag_highlight_window)
2366     {
2367       gdk_window_set_user_data (priv->drag_highlight_window, NULL);
2368       gdk_window_destroy (priv->drag_highlight_window);
2369       priv->drag_highlight_window = NULL;
2370     }
2371
2372   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
2373 }
2374
2375 /* GtkWidget::size_request helper */
2376 static void
2377 gtk_tree_view_size_request_columns (GtkTreeView *tree_view)
2378 {
2379   GList *list;
2380
2381   tree_view->priv->header_height = 0;
2382
2383   for (list = tree_view->priv->columns; list; list = list->next)
2384     {
2385       GtkRequisition     requisition;
2386       GtkTreeViewColumn *column = list->data;
2387       GtkWidget         *button = gtk_tree_view_column_get_button (column);
2388
2389       if (button == NULL)
2390         continue;
2391
2392       gtk_widget_get_preferred_size (button, &requisition, NULL);
2393       tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
2394     }
2395 }
2396
2397
2398 /* Called only by ::size_request */
2399 static void
2400 gtk_tree_view_update_size (GtkTreeView *tree_view)
2401 {
2402   GList *list;
2403   GtkTreeViewColumn *column;
2404   gint i;
2405
2406   if (tree_view->priv->model == NULL)
2407     {
2408       tree_view->priv->width = 0;
2409       tree_view->priv->prev_width = 0;
2410       tree_view->priv->height = 0;
2411       return;
2412     }
2413
2414   tree_view->priv->prev_width = tree_view->priv->width;
2415   tree_view->priv->width = 0;
2416
2417   /* keep this in sync with size_allocate below */
2418   for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
2419     {
2420       column = list->data;
2421       if (!gtk_tree_view_column_get_visible (column))
2422         continue;
2423
2424       tree_view->priv->width += _gtk_tree_view_column_request_width (column);
2425     }
2426
2427   if (tree_view->priv->tree == NULL)
2428     tree_view->priv->height = 0;
2429   else
2430     tree_view->priv->height = tree_view->priv->tree->root->offset;
2431 }
2432
2433 static void
2434 gtk_tree_view_size_request (GtkWidget      *widget,
2435                             GtkRequisition *requisition,
2436                             gboolean        may_validate)
2437 {
2438   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2439
2440   if (may_validate)
2441     {
2442       /* we validate some rows initially just to make sure we have some size.
2443        * In practice, with a lot of static lists, this should get a good width.
2444        */
2445       do_validate_rows (tree_view, FALSE);
2446     }
2447
2448   gtk_tree_view_size_request_columns (tree_view);
2449   gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
2450
2451   requisition->width = tree_view->priv->width;
2452   requisition->height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view);
2453 }
2454
2455 static void
2456 gtk_tree_view_get_preferred_width (GtkWidget *widget,
2457                                    gint      *minimum,
2458                                    gint      *natural)
2459 {
2460   GtkRequisition requisition;
2461
2462   gtk_tree_view_size_request (widget, &requisition, TRUE);
2463
2464   *minimum = *natural = requisition.width;
2465 }
2466
2467 static void
2468 gtk_tree_view_get_preferred_height (GtkWidget *widget,
2469                                     gint      *minimum,
2470                                     gint      *natural)
2471 {
2472   GtkRequisition requisition;
2473
2474   gtk_tree_view_size_request (widget, &requisition, TRUE);
2475
2476   *minimum = *natural = requisition.height;
2477 }
2478
2479 static int
2480 gtk_tree_view_calculate_width_before_expander (GtkTreeView *tree_view)
2481 {
2482   int width = 0;
2483   GList *list;
2484   gboolean rtl;
2485
2486   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2487   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2488        list->data != tree_view->priv->expander_column;
2489        list = (rtl ? list->prev : list->next))
2490     {
2491       GtkTreeViewColumn *column = list->data;
2492
2493       width += gtk_tree_view_column_get_width (column);
2494     }
2495
2496   return width;
2497 }
2498
2499 /* GtkWidget::size_allocate helper */
2500 static void
2501 gtk_tree_view_size_allocate_columns (GtkWidget *widget,
2502                                      gboolean  *width_changed)
2503 {
2504   GtkTreeView *tree_view;
2505   GList *list, *first_column, *last_column;
2506   GtkTreeViewColumn *column;
2507   GtkAllocation widget_allocation;
2508   gint width = 0;
2509   gint extra, extra_per_column, extra_for_last;
2510   gint full_requested_width = 0;
2511   gint number_of_expand_columns = 0;
2512   gboolean rtl;
2513   gboolean update_expand;
2514
2515   tree_view = GTK_TREE_VIEW (widget);
2516
2517   for (last_column = g_list_last (tree_view->priv->columns);
2518        last_column &&
2519        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
2520        last_column = last_column->prev)
2521     ;
2522   if (last_column == NULL)
2523     return;
2524
2525   for (first_column = g_list_first (tree_view->priv->columns);
2526        first_column &&
2527        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
2528        first_column = first_column->next)
2529     ;
2530
2531   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2532
2533   /* find out how many extra space and expandable columns we have */
2534   for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
2535     {
2536       column = (GtkTreeViewColumn *)list->data;
2537
2538       if (!gtk_tree_view_column_get_visible (column))
2539         continue;
2540
2541       full_requested_width += _gtk_tree_view_column_request_width (column);
2542
2543       if (gtk_tree_view_column_get_expand (column))
2544         number_of_expand_columns++;
2545     }
2546
2547   /* Only update the expand value if the width of the widget has changed,
2548    * or the number of expand columns has changed, or if there are no expand
2549    * columns, or if we didn't have an size-allocation yet after the
2550    * last validated node.
2551    */
2552   update_expand = (width_changed && *width_changed == TRUE)
2553       || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns
2554       || number_of_expand_columns == 0
2555       || tree_view->priv->post_validation_flag == TRUE;
2556
2557   tree_view->priv->post_validation_flag = FALSE;
2558
2559   gtk_widget_get_allocation (widget, &widget_allocation);
2560   if (!update_expand)
2561     {
2562       extra = tree_view->priv->last_extra_space;
2563       extra_for_last = MAX (widget_allocation.width - full_requested_width - extra, 0);
2564     }
2565   else
2566     {
2567       extra = MAX (widget_allocation.width - full_requested_width, 0);
2568       extra_for_last = 0;
2569
2570       tree_view->priv->last_extra_space = extra;
2571     }
2572
2573   if (number_of_expand_columns > 0)
2574     extra_per_column = extra/number_of_expand_columns;
2575   else
2576     extra_per_column = 0;
2577
2578   if (update_expand)
2579     {
2580       tree_view->priv->last_extra_space_per_column = extra_per_column;
2581       tree_view->priv->last_number_of_expand_columns = number_of_expand_columns;
2582     }
2583
2584   for (list = (rtl ? last_column : first_column);
2585        list != (rtl ? first_column->prev : last_column->next);
2586        list = (rtl ? list->prev : list->next))
2587     {
2588       gint column_width;
2589
2590       column = list->data;
2591
2592       if (!gtk_tree_view_column_get_visible (column))
2593         continue;
2594
2595       /* We need to handle the dragged button specially.
2596        */
2597       if (column == tree_view->priv->drag_column)
2598         {
2599           GtkAllocation drag_allocation;
2600           GtkWidget    *button;
2601
2602           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
2603
2604           drag_allocation.x = 0;
2605           drag_allocation.y = 0;
2606           drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
2607           drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
2608           gtk_widget_size_allocate (button, &drag_allocation);
2609           width += drag_allocation.width;
2610           continue;
2611         }
2612
2613       column_width = _gtk_tree_view_column_request_width (column);
2614
2615       if (gtk_tree_view_column_get_expand (column))
2616         {
2617           if (number_of_expand_columns == 1)
2618             {
2619               /* We add the remander to the last column as
2620                * */
2621               column_width += extra;
2622             }
2623           else
2624             {
2625               column_width += extra_per_column;
2626               extra -= extra_per_column;
2627               number_of_expand_columns --;
2628             }
2629         }
2630       else if (number_of_expand_columns == 0 &&
2631                list == last_column)
2632         {
2633           column_width += extra;
2634         }
2635
2636       /* In addition to expand, the last column can get even more
2637        * extra space so all available space is filled up.
2638        */
2639       if (extra_for_last > 0 && list == last_column)
2640         column_width += extra_for_last;
2641
2642       _gtk_tree_view_column_allocate (column, width, column_width);
2643
2644       width += column_width;
2645     }
2646
2647   /* We change the width here.  The user might have been resizing columns,
2648    * which changes the total width of the tree view.  This is of
2649    * importance for getting the horizontal scroll bar right.
2650    */
2651   if (tree_view->priv->width != width)
2652     {
2653       tree_view->priv->width = width;
2654       if (width_changed)
2655         *width_changed = TRUE;
2656     }
2657 }
2658
2659
2660 static void
2661 gtk_tree_view_size_allocate (GtkWidget     *widget,
2662                              GtkAllocation *allocation)
2663 {
2664   GtkAllocation widget_allocation;
2665   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2666   GList *tmp_list;
2667   gboolean width_changed = FALSE;
2668   gint old_width;
2669
2670   gtk_widget_get_allocation (widget, &widget_allocation);
2671   old_width = widget_allocation.width;
2672   if (allocation->width != widget_allocation.width)
2673     width_changed = TRUE;
2674
2675   gtk_widget_set_allocation (widget, allocation);
2676
2677   tmp_list = tree_view->priv->children;
2678
2679   while (tmp_list)
2680     {
2681       GtkAllocation allocation;
2682
2683       GtkTreeViewChild *child = tmp_list->data;
2684       tmp_list = tmp_list->next;
2685
2686       /* totally ignore our child's requisition */
2687       allocation.x = child->x;
2688       allocation.y = child->y;
2689       allocation.width = child->width;
2690       allocation.height = child->height;
2691       gtk_widget_size_allocate (child->widget, &allocation);
2692     }
2693
2694   /* We size-allocate the columns first because the width of the
2695    * tree view (used in updating the adjustments below) might change.
2696    */
2697   gtk_tree_view_size_allocate_columns (widget, &width_changed);
2698
2699   g_object_freeze_notify (G_OBJECT (tree_view->priv->hadjustment));
2700   gtk_adjustment_set_page_size (tree_view->priv->hadjustment,
2701                                 allocation->width);
2702   gtk_adjustment_set_page_increment (tree_view->priv->hadjustment,
2703                                      allocation->width * 0.9);
2704   gtk_adjustment_set_step_increment (tree_view->priv->hadjustment,
2705                                      allocation->width * 0.1);
2706   gtk_adjustment_set_lower (tree_view->priv->hadjustment, 0);
2707   gtk_adjustment_set_upper (tree_view->priv->hadjustment,
2708                             MAX (gtk_adjustment_get_page_size (tree_view->priv->hadjustment),
2709                                  tree_view->priv->width));
2710   g_object_thaw_notify (G_OBJECT (tree_view->priv->hadjustment));
2711
2712   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2713     {
2714       if (allocation->width < tree_view->priv->width)
2715         {
2716           if (tree_view->priv->init_hadjust_value)
2717             {
2718               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2719                                         MAX (tree_view->priv->width -
2720                                              allocation->width, 0));
2721               tree_view->priv->init_hadjust_value = FALSE;
2722             }
2723           else if (allocation->width != old_width)
2724             {
2725               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2726                                         CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) - allocation->width + old_width,
2727                                                0,
2728                                                tree_view->priv->width - allocation->width));
2729             }
2730           else
2731             gtk_adjustment_set_value (tree_view->priv->hadjustment,
2732                                       CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - gtk_adjustment_get_value (tree_view->priv->hadjustment)),
2733                                              0,
2734                                              tree_view->priv->width - allocation->width));
2735         }
2736       else
2737         {
2738           gtk_adjustment_set_value (tree_view->priv->hadjustment, 0);
2739           tree_view->priv->init_hadjust_value = TRUE;
2740         }
2741     }
2742   else
2743     if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + allocation->width > tree_view->priv->width)
2744       gtk_adjustment_set_value (tree_view->priv->hadjustment,
2745                                 MAX (tree_view->priv->width -
2746                                      allocation->width, 0));
2747
2748   g_object_freeze_notify (G_OBJECT (tree_view->priv->vadjustment));
2749   gtk_adjustment_set_page_size (tree_view->priv->vadjustment,
2750                                 allocation->height -
2751                                 gtk_tree_view_get_effective_header_height (tree_view));
2752   gtk_adjustment_set_step_increment (tree_view->priv->vadjustment,
2753                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.1);
2754   gtk_adjustment_set_page_increment (tree_view->priv->vadjustment,
2755                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.9);
2756   gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
2757   gtk_adjustment_set_upper (tree_view->priv->vadjustment,
2758                             MAX (gtk_adjustment_get_page_size (tree_view->priv->vadjustment),
2759                                  tree_view->priv->height));
2760   g_object_thaw_notify (G_OBJECT (tree_view->priv->vadjustment));
2761
2762   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2763   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
2764     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2765   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
2766     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2767                               tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
2768   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2769     gtk_tree_view_top_row_to_dy (tree_view);
2770   else
2771     gtk_tree_view_dy_to_top_row (tree_view);
2772
2773   if (gtk_widget_get_realized (widget))
2774     {
2775       gdk_window_move_resize (gtk_widget_get_window (widget),
2776                               allocation->x, allocation->y,
2777                               allocation->width, allocation->height);
2778       gdk_window_move_resize (tree_view->priv->header_window,
2779                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2780                               0,
2781                               MAX (tree_view->priv->width, allocation->width),
2782                               tree_view->priv->header_height);
2783       gdk_window_move_resize (tree_view->priv->bin_window,
2784                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2785                               gtk_tree_view_get_effective_header_height (tree_view),
2786                               MAX (tree_view->priv->width, allocation->width),
2787                               allocation->height - gtk_tree_view_get_effective_header_height (tree_view));
2788
2789       if (tree_view->priv->tree == NULL)
2790         invalidate_empty_focus (tree_view);
2791
2792       if (width_changed && tree_view->priv->expander_column)
2793         {
2794           /* Might seem awkward, but is the best heuristic I could come up
2795            * with.  Only if the width of the columns before the expander
2796            * changes, we will update the prelight status.  It is this
2797            * width that makes the expander move vertically.  Always updating
2798            * prelight status causes trouble with hover selections.
2799            */
2800           gint width_before_expander;
2801
2802           width_before_expander = gtk_tree_view_calculate_width_before_expander (tree_view);
2803
2804           if (tree_view->priv->prev_width_before_expander
2805               != width_before_expander)
2806               update_prelight (tree_view,
2807                                tree_view->priv->event_last_x,
2808                                tree_view->priv->event_last_y);
2809
2810           tree_view->priv->prev_width_before_expander = width_before_expander;
2811         }
2812     }
2813 }
2814
2815 /* Grabs the focus and unsets the GTK_TREE_VIEW_DRAW_KEYFOCUS flag */
2816 static void
2817 grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
2818 {
2819   GtkWidget *widget = GTK_WIDGET (tree_view);
2820
2821   if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
2822     gtk_widget_grab_focus (widget);
2823   tree_view->priv->draw_keyfocus = 0;
2824 }
2825
2826 static inline gboolean
2827 row_is_separator (GtkTreeView *tree_view,
2828                   GtkTreeIter *iter,
2829                   GtkTreePath *path)
2830 {
2831   gboolean is_separator = FALSE;
2832
2833   if (tree_view->priv->row_separator_func)
2834     {
2835       GtkTreeIter tmpiter;
2836
2837       if (iter)
2838         tmpiter = *iter;
2839       else
2840         {
2841           if (!gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path))
2842             return FALSE;
2843         }
2844
2845       is_separator = tree_view->priv->row_separator_func (tree_view->priv->model,
2846                                                           &tmpiter,
2847                                                           tree_view->priv->row_separator_data);
2848     }
2849
2850   return is_separator;
2851 }
2852
2853 static gboolean
2854 gtk_tree_view_button_press (GtkWidget      *widget,
2855                             GdkEventButton *event)
2856 {
2857   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2858   GList *list;
2859   GtkTreeViewColumn *column = NULL;
2860   gint i;
2861   GdkRectangle background_area;
2862   GdkRectangle cell_area;
2863   gint vertical_separator;
2864   gint horizontal_separator;
2865   gboolean path_is_selectable;
2866   gboolean rtl;
2867
2868   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2869   gtk_tree_view_stop_editing (tree_view, FALSE);
2870   gtk_widget_style_get (widget,
2871                         "vertical-separator", &vertical_separator,
2872                         "horizontal-separator", &horizontal_separator,
2873                         NULL);
2874
2875   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2876    * we're done handling the button press.
2877    */
2878
2879   if (event->window == tree_view->priv->bin_window)
2880     {
2881       GtkRBNode *node;
2882       GtkRBTree *tree;
2883       GtkTreePath *path;
2884       gint depth;
2885       gint new_y;
2886       gint y_offset;
2887       gint dval;
2888       gint pre_val, aft_val;
2889       GtkTreeViewColumn *column = NULL;
2890       gint column_handled_click = FALSE;
2891       gboolean row_double_click = FALSE;
2892       gboolean rtl;
2893       gboolean node_selected;
2894       GdkModifierType extend_mod_mask;
2895       GdkModifierType modify_mod_mask;
2896
2897       /* Empty tree? */
2898       if (tree_view->priv->tree == NULL)
2899         {
2900           grab_focus_and_unset_draw_keyfocus (tree_view);
2901           return TRUE;
2902         }
2903
2904       /* are we in an arrow? */
2905       if (tree_view->priv->prelight_node &&
2906           tree_view->priv->arrow_prelit &&
2907           gtk_tree_view_draw_expanders (tree_view))
2908         {
2909           if (event->button == GDK_BUTTON_PRIMARY)
2910             {
2911               gtk_grab_add (widget);
2912               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2913               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2914               gtk_tree_view_queue_draw_arrow (GTK_TREE_VIEW (widget),
2915                                               tree_view->priv->prelight_tree,
2916                                               tree_view->priv->prelight_node);
2917             }
2918
2919           grab_focus_and_unset_draw_keyfocus (tree_view);
2920           return TRUE;
2921         }
2922
2923       /* find the node that was clicked */
2924       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
2925       if (new_y < 0)
2926         new_y = 0;
2927       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
2928
2929       if (node == NULL)
2930         {
2931           /* We clicked in dead space */
2932           grab_focus_and_unset_draw_keyfocus (tree_view);
2933           return TRUE;
2934         }
2935
2936       /* Get the path and the node */
2937       path = _gtk_tree_path_new_from_rbtree (tree, node);
2938       path_is_selectable = !row_is_separator (tree_view, NULL, path);
2939
2940       if (!path_is_selectable)
2941         {
2942           gtk_tree_path_free (path);
2943           grab_focus_and_unset_draw_keyfocus (tree_view);
2944           return TRUE;
2945         }
2946
2947       depth = gtk_tree_path_get_depth (path);
2948       background_area.y = y_offset + event->y;
2949       background_area.height = gtk_tree_view_get_row_height (tree_view, node);
2950       background_area.x = 0;
2951
2952
2953       /* Let the column have a chance at selecting it. */
2954       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2955       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2956            list; list = (rtl ? list->prev : list->next))
2957         {
2958           GtkTreeViewColumn *candidate = list->data;
2959
2960           if (!gtk_tree_view_column_get_visible (candidate))
2961             continue;
2962
2963           background_area.width = gtk_tree_view_column_get_width (candidate);
2964           if ((background_area.x > (gint) event->x) ||
2965               (background_area.x + background_area.width <= (gint) event->x))
2966             {
2967               background_area.x += background_area.width;
2968               continue;
2969             }
2970
2971           /* we found the focus column */
2972           column = candidate;
2973           cell_area = background_area;
2974           cell_area.width -= horizontal_separator;
2975           cell_area.height -= vertical_separator;
2976           cell_area.x += horizontal_separator/2;
2977           cell_area.y += vertical_separator/2;
2978           if (gtk_tree_view_is_expander_column (tree_view, column))
2979             {
2980               if (!rtl)
2981                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
2982               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
2983
2984               if (gtk_tree_view_draw_expanders (tree_view))
2985                 {
2986                   if (!rtl)
2987                     cell_area.x += depth * tree_view->priv->expander_size;
2988                   cell_area.width -= depth * tree_view->priv->expander_size;
2989                 }
2990             }
2991           break;
2992         }
2993
2994       if (column == NULL)
2995         {
2996           gtk_tree_path_free (path);
2997           grab_focus_and_unset_draw_keyfocus (tree_view);
2998           return FALSE;
2999         }
3000
3001       _gtk_tree_view_set_focus_column (tree_view, column);
3002
3003       /* decide if we edit */
3004       if (event->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_PRIMARY &&
3005           !(event->state & gtk_accelerator_get_default_mod_mask ()))
3006         {
3007           GtkTreePath *anchor;
3008           GtkTreeIter iter;
3009
3010           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
3011           gtk_tree_view_column_cell_set_cell_data (column,
3012                                                    tree_view->priv->model,
3013                                                    &iter,
3014                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
3015                                                    node->children?TRUE:FALSE);
3016
3017           if (tree_view->priv->anchor)
3018             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
3019           else
3020             anchor = NULL;
3021
3022           if ((anchor && !gtk_tree_path_compare (anchor, path))
3023               || !_gtk_tree_view_column_has_editable_cell (column))
3024             {
3025               GtkCellEditable *cell_editable = NULL;
3026
3027               /* FIXME: get the right flags */
3028               guint flags = 0;
3029
3030               if (_gtk_tree_view_column_cell_event (column,
3031                                                     (GdkEvent *)event,
3032                                                     &cell_area, flags))
3033                 {
3034                   GtkCellArea *area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
3035                   cell_editable = gtk_cell_area_get_edit_widget (area);
3036
3037                   if (cell_editable != NULL)
3038                     {
3039                       gtk_tree_path_free (path);
3040                       gtk_tree_path_free (anchor);
3041                       return TRUE;
3042                     }
3043                   column_handled_click = TRUE;
3044                 }
3045             }
3046           if (anchor)
3047             gtk_tree_path_free (anchor);
3048         }
3049
3050       extend_mod_mask =
3051         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
3052
3053       modify_mod_mask =
3054         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
3055
3056       /* select */
3057       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
3058       pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3059
3060       /* we only handle selection modifications on the first button press
3061        */
3062       if (event->type == GDK_BUTTON_PRESS)
3063         {
3064           GtkCellRenderer *focus_cell;
3065
3066           if ((event->state & modify_mod_mask) == modify_mod_mask)
3067             tree_view->priv->modify_selection_pressed = TRUE;
3068           if ((event->state & extend_mod_mask) == extend_mod_mask)
3069             tree_view->priv->extend_selection_pressed = TRUE;
3070
3071           /* We update the focus cell here, this is also needed if the
3072            * column does not contain an editable cell.  In this case,
3073            * GtkCellArea did not receive the event for processing (and
3074            * could not update the focus cell).
3075            */
3076           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column,
3077                                                               &cell_area,
3078                                                               &background_area,
3079                                                               event->x,
3080                                                               event->y);
3081
3082           if (focus_cell)
3083             gtk_tree_view_column_focus_cell (column, focus_cell);
3084
3085           if (event->state & modify_mod_mask)
3086             {
3087               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3088               gtk_tree_view_real_toggle_cursor_row (tree_view);
3089             }
3090           else if (event->state & extend_mod_mask)
3091             {
3092               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3093               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
3094             }
3095           else
3096             {
3097               gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
3098             }
3099
3100           tree_view->priv->modify_selection_pressed = FALSE;
3101           tree_view->priv->extend_selection_pressed = FALSE;
3102         }
3103
3104       /* the treeview may have been scrolled because of _set_cursor,
3105        * correct here
3106        */
3107
3108       aft_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3109       dval = pre_val - aft_val;
3110
3111       cell_area.y += dval;
3112       background_area.y += dval;
3113
3114       /* Save press to possibly begin a drag
3115        */
3116       if (!column_handled_click &&
3117           !tree_view->priv->in_grab &&
3118           tree_view->priv->pressed_button < 0)
3119         {
3120           tree_view->priv->pressed_button = event->button;
3121           tree_view->priv->press_start_x = event->x;
3122           tree_view->priv->press_start_y = event->y;
3123
3124           if (tree_view->priv->rubber_banding_enable
3125               && !node_selected
3126               && gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
3127             {
3128               tree_view->priv->press_start_y += tree_view->priv->dy;
3129               tree_view->priv->rubber_band_x = event->x;
3130               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
3131               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
3132
3133               if ((event->state & modify_mod_mask) == modify_mod_mask)
3134                 tree_view->priv->rubber_band_modify = TRUE;
3135               if ((event->state & extend_mod_mask) == extend_mod_mask)
3136                 tree_view->priv->rubber_band_extend = TRUE;
3137             }
3138         }
3139
3140       /* Test if a double click happened on the same row. */
3141       if (event->button == GDK_BUTTON_PRIMARY && event->type == GDK_BUTTON_PRESS)
3142         {
3143           int double_click_time, double_click_distance;
3144
3145           g_object_get (gtk_settings_get_default (),
3146                         "gtk-double-click-time", &double_click_time,
3147                         "gtk-double-click-distance", &double_click_distance,
3148                         NULL);
3149
3150           /* Same conditions as _gdk_event_button_generate */
3151           if (tree_view->priv->last_button_x != -1 &&
3152               (event->time < tree_view->priv->last_button_time + double_click_time) &&
3153               (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
3154               (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
3155             {
3156               /* We do no longer compare paths of this row and the
3157                * row clicked previously.  We use the double click
3158                * distance to decide whether this is a valid click,
3159                * allowing the mouse to slightly move over another row.
3160                */
3161               row_double_click = TRUE;
3162
3163               tree_view->priv->last_button_time = 0;
3164               tree_view->priv->last_button_x = -1;
3165               tree_view->priv->last_button_y = -1;
3166             }
3167           else
3168             {
3169               tree_view->priv->last_button_time = event->time;
3170               tree_view->priv->last_button_x = event->x;
3171               tree_view->priv->last_button_y = event->y;
3172             }
3173         }
3174
3175       if (row_double_click)
3176         {
3177           gtk_grab_remove (widget);
3178           gtk_tree_view_row_activated (tree_view, path, column);
3179
3180           if (tree_view->priv->pressed_button == event->button)
3181             tree_view->priv->pressed_button = -1;
3182         }
3183
3184       gtk_tree_path_free (path);
3185
3186       /* If we activated the row through a double click we don't want to grab
3187        * focus back, as moving focus to another widget is pretty common.
3188        */
3189       if (!row_double_click)
3190         grab_focus_and_unset_draw_keyfocus (tree_view);
3191
3192       return TRUE;
3193     }
3194
3195   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
3196    */
3197   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
3198     {
3199       column = list->data;
3200       if (event->window == _gtk_tree_view_column_get_window (column) &&
3201           gtk_tree_view_column_get_resizable (column) &&
3202           _gtk_tree_view_column_get_window (column))
3203         {
3204           gpointer drag_data;
3205
3206           if (event->type == GDK_2BUTTON_PRESS &&
3207               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
3208             {
3209               _gtk_tree_view_column_set_use_resized_width (column, FALSE);
3210               _gtk_tree_view_column_autosize (tree_view, column);
3211               return TRUE;
3212             }
3213
3214           if (gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
3215                                _gtk_tree_view_column_get_window (column),
3216                                GDK_OWNERSHIP_NONE,
3217                                FALSE,
3218                                GDK_POINTER_MOTION_HINT_MASK
3219                                 | GDK_BUTTON1_MOTION_MASK
3220                                 | GDK_BUTTON_RELEASE_MASK,
3221                                NULL,
3222                                event->time) != GDK_GRAB_SUCCESS)
3223             return FALSE;
3224
3225           gtk_grab_add (widget);
3226           tree_view->priv->in_column_resize = TRUE;
3227
3228           _gtk_tree_view_column_set_resized_width (column, gtk_tree_view_column_get_width (column) -
3229                                                    tree_view->priv->last_extra_space_per_column);
3230
3231           /* block attached dnd signal handler */
3232           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3233           if (drag_data)
3234             g_signal_handlers_block_matched (widget,
3235                                              G_SIGNAL_MATCH_DATA,
3236                                              0, 0, NULL, NULL,
3237                                              drag_data);
3238
3239           tree_view->priv->drag_pos = i;
3240           tree_view->priv->x_drag = gtk_tree_view_column_get_x_offset (column) + (rtl ? 0 : gtk_tree_view_column_get_width (column));
3241
3242           if (!gtk_widget_has_focus (widget))
3243             gtk_widget_grab_focus (widget);
3244
3245           return TRUE;
3246         }
3247     }
3248   return FALSE;
3249 }
3250
3251 /* GtkWidget::button_release_event helper */
3252 static gboolean
3253 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
3254                                           GdkEventButton *event)
3255 {
3256   GtkTreeView *tree_view;
3257   GtkWidget *button;
3258   GList *l;
3259   gboolean rtl;
3260   GdkDevice *device, *other;
3261
3262   tree_view = GTK_TREE_VIEW (widget);
3263
3264   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
3265   device = gdk_event_get_device ((GdkEvent*)event);
3266   other = gdk_device_get_associated_device (device);
3267   gdk_device_ungrab (device, event->time);
3268   gdk_device_ungrab (other, event->time);
3269
3270   /* Move the button back */
3271   button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3272   g_object_ref (button);
3273   gtk_container_remove (GTK_CONTAINER (tree_view), button);
3274   gtk_widget_set_parent_window (button, tree_view->priv->header_window);
3275   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
3276   g_object_unref (button);
3277   gtk_widget_queue_resize (widget);
3278   if (gtk_tree_view_column_get_resizable (tree_view->priv->drag_column))
3279     {
3280       gdk_window_raise (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3281       gdk_window_show (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3282     }
3283   else
3284     gdk_window_hide (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3285
3286   gtk_widget_grab_focus (button);
3287
3288   if (rtl)
3289     {
3290       if (tree_view->priv->cur_reorder &&
3291           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
3292         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3293                                          tree_view->priv->cur_reorder->right_column);
3294     }
3295   else
3296     {
3297       if (tree_view->priv->cur_reorder &&
3298           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
3299         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3300                                          tree_view->priv->cur_reorder->left_column);
3301     }
3302   tree_view->priv->drag_column = NULL;
3303   gdk_window_hide (tree_view->priv->drag_window);
3304
3305   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
3306     g_slice_free (GtkTreeViewColumnReorder, l->data);
3307   g_list_free (tree_view->priv->column_drag_info);
3308   tree_view->priv->column_drag_info = NULL;
3309   tree_view->priv->cur_reorder = NULL;
3310
3311   if (tree_view->priv->drag_highlight_window)
3312     gdk_window_hide (tree_view->priv->drag_highlight_window);
3313
3314   /* Reset our flags */
3315   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
3316   tree_view->priv->in_column_drag = FALSE;
3317
3318   return TRUE;
3319 }
3320
3321 /* GtkWidget::button_release_event helper */
3322 static gboolean
3323 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
3324                                             GdkEventButton *event)
3325 {
3326   GtkTreeView *tree_view;
3327   gpointer drag_data;
3328
3329   tree_view = GTK_TREE_VIEW (widget);
3330
3331   tree_view->priv->drag_pos = -1;
3332
3333   /* unblock attached dnd signal handler */
3334   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3335   if (drag_data)
3336     g_signal_handlers_unblock_matched (widget,
3337                                        G_SIGNAL_MATCH_DATA,
3338                                        0, 0, NULL, NULL,
3339                                        drag_data);
3340
3341   tree_view->priv->in_column_resize = FALSE;
3342   gtk_grab_remove (widget);
3343   gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
3344   return TRUE;
3345 }
3346
3347 static gboolean
3348 gtk_tree_view_button_release (GtkWidget      *widget,
3349                               GdkEventButton *event)
3350 {
3351   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3352
3353   if (tree_view->priv->in_column_drag)
3354     return gtk_tree_view_button_release_drag_column (widget, event);
3355
3356   if (tree_view->priv->rubber_band_status)
3357     gtk_tree_view_stop_rubber_band (tree_view);
3358
3359   if (tree_view->priv->pressed_button == event->button)
3360     tree_view->priv->pressed_button = -1;
3361
3362   if (tree_view->priv->in_column_resize)
3363     return gtk_tree_view_button_release_column_resize (widget, event);
3364
3365   if (tree_view->priv->button_pressed_node == NULL)
3366     return FALSE;
3367
3368   if (event->button == GDK_BUTTON_PRIMARY)
3369     {
3370       if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
3371           tree_view->priv->arrow_prelit)
3372         {
3373           GtkTreePath *path = NULL;
3374
3375           path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
3376                                                  tree_view->priv->button_pressed_node);
3377           /* Actually activate the node */
3378           if (tree_view->priv->button_pressed_node->children == NULL)
3379             gtk_tree_view_real_expand_row (tree_view, path,
3380                                            tree_view->priv->button_pressed_tree,
3381                                            tree_view->priv->button_pressed_node,
3382                                            FALSE, TRUE);
3383           else
3384             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3385                                              tree_view->priv->button_pressed_tree,
3386                                              tree_view->priv->button_pressed_node, TRUE);
3387           gtk_tree_path_free (path);
3388         }
3389
3390       gtk_grab_remove (widget);
3391       tree_view->priv->button_pressed_tree = NULL;
3392       tree_view->priv->button_pressed_node = NULL;
3393     }
3394
3395   return TRUE;
3396 }
3397
3398 static gboolean
3399 gtk_tree_view_grab_broken (GtkWidget          *widget,
3400                            GdkEventGrabBroken *event)
3401 {
3402   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3403
3404   if (tree_view->priv->in_column_drag)
3405     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3406
3407   if (tree_view->priv->in_column_resize)
3408     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3409
3410   return TRUE;
3411 }
3412
3413 #if 0
3414 static gboolean
3415 gtk_tree_view_configure (GtkWidget *widget,
3416                          GdkEventConfigure *event)
3417 {
3418   GtkTreeView *tree_view;
3419
3420   tree_view = GTK_TREE_VIEW (widget);
3421   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3422
3423   return FALSE;
3424 }
3425 #endif
3426
3427 /* GtkWidget::motion_event function set.
3428  */
3429
3430 static gboolean
3431 coords_are_over_arrow (GtkTreeView *tree_view,
3432                        GtkRBTree   *tree,
3433                        GtkRBNode   *node,
3434                        /* these are in bin window coords */
3435                        gint         x,
3436                        gint         y)
3437 {
3438   GdkRectangle arrow;
3439   gint x2;
3440
3441   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
3442     return FALSE;
3443
3444   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3445     return FALSE;
3446
3447   arrow.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
3448   arrow.height = gtk_tree_view_get_row_height (tree_view, node);
3449
3450   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3451
3452   arrow.width = x2 - arrow.x;
3453
3454   return (x >= arrow.x &&
3455           x < (arrow.x + arrow.width) &&
3456           y >= arrow.y &&
3457           y < (arrow.y + arrow.height));
3458 }
3459
3460 static gboolean
3461 auto_expand_timeout (gpointer data)
3462 {
3463   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3464   GtkTreePath *path;
3465
3466   if (tree_view->priv->prelight_node)
3467     {
3468       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->prelight_tree,
3469                                              tree_view->priv->prelight_node);
3470
3471       if (tree_view->priv->prelight_node->children)
3472         gtk_tree_view_collapse_row (tree_view, path);
3473       else
3474         gtk_tree_view_expand_row (tree_view, path, FALSE);
3475
3476       gtk_tree_path_free (path);
3477     }
3478
3479   tree_view->priv->auto_expand_timeout = 0;
3480
3481   return FALSE;
3482 }
3483
3484 static void
3485 remove_auto_expand_timeout (GtkTreeView *tree_view)
3486 {
3487   if (tree_view->priv->auto_expand_timeout != 0)
3488     {
3489       g_source_remove (tree_view->priv->auto_expand_timeout);
3490       tree_view->priv->auto_expand_timeout = 0;
3491     }
3492 }
3493
3494 static void
3495 do_prelight (GtkTreeView *tree_view,
3496              GtkRBTree   *tree,
3497              GtkRBNode   *node,
3498              /* these are in bin_window coords */
3499              gint         x,
3500              gint         y)
3501 {
3502   if (tree_view->priv->prelight_tree == tree &&
3503       tree_view->priv->prelight_node == node)
3504     {
3505       /*  We are still on the same node,
3506           but we might need to take care of the arrow  */
3507
3508       if (tree && node && gtk_tree_view_draw_expanders (tree_view))
3509         {
3510           gboolean over_arrow;
3511
3512           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3513
3514           if (over_arrow != tree_view->priv->arrow_prelit)
3515             {
3516               if (over_arrow)
3517                 tree_view->priv->arrow_prelit = TRUE;
3518               else
3519                 tree_view->priv->arrow_prelit = FALSE;
3520
3521               gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3522             }
3523         }
3524
3525       return;
3526     }
3527
3528   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3529     {
3530       /*  Unprelight the old node and arrow  */
3531
3532       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3533                              GTK_RBNODE_IS_PRELIT);
3534
3535       if (tree_view->priv->arrow_prelit
3536           && gtk_tree_view_draw_expanders (tree_view))
3537         {
3538           tree_view->priv->arrow_prelit = FALSE;
3539
3540           gtk_tree_view_queue_draw_arrow (tree_view,
3541                                           tree_view->priv->prelight_tree,
3542                                           tree_view->priv->prelight_node);
3543         }
3544
3545       _gtk_tree_view_queue_draw_node (tree_view,
3546                                       tree_view->priv->prelight_tree,
3547                                       tree_view->priv->prelight_node,
3548                                       NULL);
3549     }
3550
3551
3552   if (tree_view->priv->hover_expand)
3553     remove_auto_expand_timeout (tree_view);
3554
3555   /*  Set the new prelight values  */
3556   tree_view->priv->prelight_node = node;
3557   tree_view->priv->prelight_tree = tree;
3558
3559   if (!node || !tree)
3560     return;
3561
3562   /*  Prelight the new node and arrow  */
3563
3564   if (gtk_tree_view_draw_expanders (tree_view)
3565       && coords_are_over_arrow (tree_view, tree, node, x, y))
3566     {
3567       tree_view->priv->arrow_prelit = TRUE;
3568
3569       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3570     }
3571
3572   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3573
3574   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3575
3576   if (tree_view->priv->hover_expand)
3577     {
3578       tree_view->priv->auto_expand_timeout =
3579         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3580     }
3581 }
3582
3583 static void
3584 prelight_or_select (GtkTreeView *tree_view,
3585                     GtkRBTree   *tree,
3586                     GtkRBNode   *node,
3587                     /* these are in bin_window coords */
3588                     gint         x,
3589                     gint         y)
3590 {
3591   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3592
3593   if (tree_view->priv->hover_selection &&
3594       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3595       !(tree_view->priv->edited_column &&
3596         gtk_cell_area_get_edit_widget
3597         (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column)))))
3598     {
3599       if (node)
3600         {
3601           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3602             {
3603               GtkTreePath *path;
3604
3605               path = _gtk_tree_path_new_from_rbtree (tree, node);
3606               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3607               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3608                 {
3609                   tree_view->priv->draw_keyfocus = FALSE;
3610                   gtk_tree_view_real_set_cursor (tree_view, path, 0);
3611                 }
3612               gtk_tree_path_free (path);
3613             }
3614         }
3615
3616       else if (mode == GTK_SELECTION_SINGLE)
3617         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3618     }
3619
3620     do_prelight (tree_view, tree, node, x, y);
3621 }
3622
3623 static void
3624 ensure_unprelighted (GtkTreeView *tree_view)
3625 {
3626   do_prelight (tree_view,
3627                NULL, NULL,
3628                -1000, -1000); /* coords not possibly over an arrow */
3629
3630   g_assert (tree_view->priv->prelight_node == NULL);
3631 }
3632
3633 static void
3634 update_prelight (GtkTreeView *tree_view,
3635                  gint         x,
3636                  gint         y)
3637 {
3638   int new_y;
3639   GtkRBTree *tree;
3640   GtkRBNode *node;
3641
3642   if (tree_view->priv->tree == NULL)
3643     return;
3644
3645   if (x == -10000)
3646     {
3647       ensure_unprelighted (tree_view);
3648       return;
3649     }
3650
3651   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
3652   if (new_y < 0)
3653     new_y = 0;
3654
3655   _gtk_rbtree_find_offset (tree_view->priv->tree,
3656                            new_y, &tree, &node);
3657
3658   if (node)
3659     prelight_or_select (tree_view, tree, node, x, y);
3660 }
3661
3662
3663
3664
3665 /* Our motion arrow is either a box (in the case of the original spot)
3666  * or an arrow.  It is expander_size wide.
3667  */
3668 /*
3669  * 11111111111111
3670  * 01111111111110
3671  * 00111111111100
3672  * 00011111111000
3673  * 00001111110000
3674  * 00000111100000
3675  * 00000111100000
3676  * 00000111100000
3677  * ~ ~ ~ ~ ~ ~ ~
3678  * 00000111100000
3679  * 00000111100000
3680  * 00000111100000
3681  * 00001111110000
3682  * 00011111111000
3683  * 00111111111100
3684  * 01111111111110
3685  * 11111111111111
3686  */
3687
3688 static void
3689 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3690 {
3691   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3692   GtkWidget *widget = GTK_WIDGET (tree_view);
3693   cairo_surface_t *mask_image;
3694   cairo_region_t *mask_region;
3695   gint x;
3696   gint y;
3697   gint width;
3698   gint height;
3699   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3700   GdkWindowAttr attributes;
3701   guint attributes_mask;
3702   cairo_t *cr;
3703
3704   if (!reorder ||
3705       reorder->left_column == tree_view->priv->drag_column ||
3706       reorder->right_column == tree_view->priv->drag_column)
3707     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3708   else if (reorder->left_column || reorder->right_column)
3709     {
3710       GtkAllocation left_allocation, right_allocation;
3711       GdkRectangle visible_rect;
3712       GtkWidget *button;
3713
3714       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3715       if (reorder->left_column)
3716         {
3717           button = gtk_tree_view_column_get_button (reorder->left_column);
3718           gtk_widget_get_allocation (button, &left_allocation);
3719           x = left_allocation.x + left_allocation.width;
3720         }
3721       else
3722         {
3723           button = gtk_tree_view_column_get_button (reorder->right_column);
3724           gtk_widget_get_allocation (button, &right_allocation);
3725           x = right_allocation.x;
3726         }
3727
3728       if (x < visible_rect.x)
3729         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3730       else if (x > visible_rect.x + visible_rect.width)
3731         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3732       else
3733         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3734     }
3735
3736   /* We want to draw the rectangle over the initial location. */
3737   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3738     {
3739       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3740         {
3741           GtkAllocation drag_allocation;
3742           GtkWidget    *button;
3743
3744           if (tree_view->priv->drag_highlight_window)
3745             {
3746               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3747                                         NULL);
3748               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3749             }
3750
3751           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3752           attributes.window_type = GDK_WINDOW_CHILD;
3753           attributes.wclass = GDK_INPUT_OUTPUT;
3754           attributes.x = tree_view->priv->drag_column_x;
3755           attributes.y = 0;
3756           gtk_widget_get_allocation (button, &drag_allocation);
3757           width = attributes.width = drag_allocation.width;
3758           height = attributes.height = drag_allocation.height;
3759           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3760           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3761           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3762           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3763           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3764
3765           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3766           cr = cairo_create (mask_image);
3767
3768           cairo_rectangle (cr, 1, 1, width - 2, height - 2);
3769           cairo_stroke (cr);
3770           cairo_destroy (cr);
3771
3772           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3773           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3774                                            mask_region, 0, 0);
3775
3776           cairo_region_destroy (mask_region);
3777           cairo_surface_destroy (mask_image);
3778
3779           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3780         }
3781     }
3782   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3783     {
3784       GtkAllocation button_allocation;
3785       GtkWidget    *button;
3786
3787       width = tree_view->priv->expander_size;
3788
3789       /* Get x, y, width, height of arrow */
3790       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3791       if (reorder->left_column)
3792         {
3793           button = gtk_tree_view_column_get_button (reorder->left_column);
3794           gtk_widget_get_allocation (button, &button_allocation);
3795           x += button_allocation.x + button_allocation.width - width/2;
3796           height = button_allocation.height;
3797         }
3798       else
3799         {
3800           button = gtk_tree_view_column_get_button (reorder->right_column);
3801           gtk_widget_get_allocation (button, &button_allocation);
3802           x += button_allocation.x - width/2;
3803           height = button_allocation.height;
3804         }
3805       y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */
3806       height += tree_view->priv->expander_size;
3807
3808       /* Create the new window */
3809       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3810         {
3811           if (tree_view->priv->drag_highlight_window)
3812             {
3813               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3814                                         NULL);
3815               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3816             }
3817
3818           attributes.window_type = GDK_WINDOW_TEMP;
3819           attributes.wclass = GDK_INPUT_OUTPUT;
3820           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3821           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3822           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3823           attributes.x = x;
3824           attributes.y = y;
3825           attributes.width = width;
3826           attributes.height = height;
3827           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3828                                                                    &attributes, attributes_mask);
3829           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3830
3831           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3832
3833           cr = cairo_create (mask_image);
3834           cairo_move_to (cr, 0, 0);
3835           cairo_line_to (cr, width, 0);
3836           cairo_line_to (cr, width / 2., width / 2);
3837           cairo_move_to (cr, 0, height);
3838           cairo_line_to (cr, width, height);
3839           cairo_line_to (cr, width / 2., height - width / 2.);
3840           cairo_fill (cr);
3841           cairo_destroy (cr);
3842
3843           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3844           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3845                                            mask_region, 0, 0);
3846
3847           cairo_region_destroy (mask_region);
3848           cairo_surface_destroy (mask_image);
3849         }
3850
3851       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3852       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3853     }
3854   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3855            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3856     {
3857       GtkAllocation allocation;
3858       GtkWidget    *button;
3859
3860       width = tree_view->priv->expander_size;
3861
3862       /* Get x, y, width, height of arrow */
3863       width = width/2; /* remember, the arrow only takes half the available width */
3864       gdk_window_get_origin (gtk_widget_get_window (widget),
3865                              &x, &y);
3866       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3867         {
3868           gtk_widget_get_allocation (widget, &allocation);
3869           x += allocation.width - width;
3870         }
3871
3872       if (reorder->left_column)
3873         {
3874           button = gtk_tree_view_column_get_button (reorder->left_column);
3875           gtk_widget_get_allocation (button, &allocation);
3876           height = allocation.height;
3877         }
3878       else
3879         {
3880           button = gtk_tree_view_column_get_button (reorder->right_column);
3881           gtk_widget_get_allocation (button, &allocation);
3882           height = allocation.height;
3883         }
3884
3885       y -= tree_view->priv->expander_size;
3886       height += 2*tree_view->priv->expander_size;
3887
3888       /* Create the new window */
3889       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3890           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3891         {
3892           if (tree_view->priv->drag_highlight_window)
3893             {
3894               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3895                                         NULL);
3896               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3897             }
3898
3899           attributes.window_type = GDK_WINDOW_TEMP;
3900           attributes.wclass = GDK_INPUT_OUTPUT;
3901           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3902           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3903           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3904           attributes.x = x;
3905           attributes.y = y;
3906           attributes.width = width;
3907           attributes.height = height;
3908           tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
3909           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3910
3911           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3912
3913           cr = cairo_create (mask_image);
3914           /* mirror if we're on the left */
3915           if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3916             {
3917               cairo_translate (cr, width, 0);
3918               cairo_scale (cr, -1, 1);
3919             }
3920           cairo_move_to (cr, 0, 0);
3921           cairo_line_to (cr, width, width);
3922           cairo_line_to (cr, 0, tree_view->priv->expander_size);
3923           cairo_move_to (cr, 0, height);
3924           cairo_line_to (cr, width, height - width);
3925           cairo_line_to (cr, 0, height - tree_view->priv->expander_size);
3926           cairo_fill (cr);
3927           cairo_destroy (cr);
3928
3929           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3930           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3931                                            mask_region, 0, 0);
3932
3933           cairo_region_destroy (mask_region);
3934           cairo_surface_destroy (mask_image);
3935         }
3936
3937       tree_view->priv->drag_column_window_state = arrow_type;
3938       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3939    }
3940   else
3941     {
3942       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
3943       gdk_window_hide (tree_view->priv->drag_highlight_window);
3944       return;
3945     }
3946
3947   gdk_window_show (tree_view->priv->drag_highlight_window);
3948   gdk_window_raise (tree_view->priv->drag_highlight_window);
3949 }
3950
3951 static gboolean
3952 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
3953                                     GdkEventMotion *event)
3954 {
3955   gint x;
3956   gint new_width;
3957   GtkTreeViewColumn *column;
3958   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3959
3960   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
3961
3962   if (event->is_hint || event->window != gtk_widget_get_window (widget))
3963     gdk_window_get_device_position (gtk_widget_get_window (widget),
3964                                     gdk_event_get_device ((GdkEvent *) event),
3965                                     &x, NULL, NULL);
3966   else
3967     x = event->x;
3968
3969   if (tree_view->priv->hadjustment)
3970     x += gtk_adjustment_get_value (tree_view->priv->hadjustment);
3971
3972   new_width = gtk_tree_view_new_column_width (tree_view,
3973                                               tree_view->priv->drag_pos, &x);
3974   if (x != tree_view->priv->x_drag &&
3975       (new_width != gtk_tree_view_column_get_fixed_width (column)))
3976     {
3977       _gtk_tree_view_column_set_use_resized_width (column, TRUE);
3978
3979       if (gtk_tree_view_column_get_expand (column))
3980         new_width -= tree_view->priv->last_extra_space_per_column;
3981
3982       _gtk_tree_view_column_set_resized_width (column, new_width);
3983
3984
3985       gtk_widget_queue_resize (widget);
3986     }
3987
3988   return FALSE;
3989 }
3990
3991
3992 static void
3993 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view,
3994                                       GdkEvent    *event)
3995 {
3996   GtkTreeViewColumnReorder *reorder = NULL;
3997   GList *list;
3998   gint mouse_x;
3999
4000   gdk_window_get_device_position (tree_view->priv->header_window,
4001                                   gdk_event_get_device (event),
4002                                   &mouse_x, NULL, NULL);
4003   for (list = tree_view->priv->column_drag_info; list; list = list->next)
4004     {
4005       reorder = (GtkTreeViewColumnReorder *) list->data;
4006       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
4007         break;
4008       reorder = NULL;
4009     }
4010
4011   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
4012       return;*/
4013
4014   tree_view->priv->cur_reorder = reorder;
4015   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
4016 }
4017
4018 static void
4019 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
4020 {
4021   GdkRectangle visible_rect;
4022   gint y;
4023   gint offset;
4024
4025   gdk_window_get_device_position (tree_view->priv->bin_window,
4026                                   gdk_device_manager_get_client_pointer (
4027                                     gdk_display_get_device_manager (
4028                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4029                                   NULL, &y, NULL);
4030   y += tree_view->priv->dy;
4031
4032   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4033
4034   /* see if we are near the edge. */
4035   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
4036   if (offset > 0)
4037     {
4038       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
4039       if (offset < 0)
4040         return;
4041     }
4042
4043   gtk_adjustment_set_value (tree_view->priv->vadjustment,
4044                             MAX (gtk_adjustment_get_value (tree_view->priv->vadjustment) + offset, 0.0));
4045 }
4046
4047 static gboolean
4048 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view,
4049                                      GdkEvent    *event)
4050 {
4051   GdkRectangle visible_rect;
4052   gint x;
4053   gint offset;
4054
4055   gdk_window_get_device_position (tree_view->priv->bin_window,
4056                                   gdk_event_get_device (event),
4057                                   &x, NULL, NULL);
4058
4059   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4060
4061   /* See if we are near the edge. */
4062   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
4063   if (offset > 0)
4064     {
4065       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
4066       if (offset < 0)
4067         return TRUE;
4068     }
4069   offset = offset/3;
4070
4071   gtk_adjustment_set_value (tree_view->priv->hadjustment,
4072                             MAX (gtk_adjustment_get_value (tree_view->priv->hadjustment) + offset, 0.0));
4073
4074   return TRUE;
4075
4076 }
4077
4078 static gboolean
4079 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
4080                                   GdkEventMotion *event)
4081 {
4082   GtkAllocation allocation, button_allocation;
4083   GtkTreeView *tree_view = (GtkTreeView *) widget;
4084   GtkTreeViewColumn *column = tree_view->priv->drag_column;
4085   GtkWidget *button;
4086   gint x, y;
4087
4088   /* Sanity Check */
4089   if ((column == NULL) ||
4090       (event->window != tree_view->priv->drag_window))
4091     return FALSE;
4092
4093   button = gtk_tree_view_column_get_button (column);
4094
4095   /* Handle moving the header */
4096   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
4097   gtk_widget_get_allocation (widget, &allocation);
4098   gtk_widget_get_allocation (button, &button_allocation);
4099   x = CLAMP (x + (gint)event->x - _gtk_tree_view_column_get_drag_x (column), 0,
4100              MAX (tree_view->priv->width, allocation.width) - button_allocation.width);
4101   gdk_window_move (tree_view->priv->drag_window, x, y);
4102
4103   /* autoscroll, if needed */
4104   gtk_tree_view_horizontal_autoscroll (tree_view, (GdkEvent *) event);
4105   /* Update the current reorder position and arrow; */
4106   gtk_tree_view_update_current_reorder (tree_view, (GdkEvent *) event);
4107
4108   return TRUE;
4109 }
4110
4111 static void
4112 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
4113 {
4114   remove_scroll_timeout (tree_view);
4115   gtk_grab_remove (GTK_WIDGET (tree_view));
4116
4117   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4118     {
4119       GtkTreePath *tmp_path;
4120
4121       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4122
4123       /* The anchor path should be set to the start path */
4124       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_start_tree,
4125                                                  tree_view->priv->rubber_band_start_node);
4126
4127       if (tree_view->priv->anchor)
4128         gtk_tree_row_reference_free (tree_view->priv->anchor);
4129
4130       tree_view->priv->anchor =
4131         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
4132                                           tree_view->priv->model,
4133                                           tmp_path);
4134
4135       gtk_tree_path_free (tmp_path);
4136
4137       /* ... and the cursor to the end path */
4138       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_end_tree,
4139                                                  tree_view->priv->rubber_band_end_node);
4140       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, 0);
4141       gtk_tree_path_free (tmp_path);
4142
4143       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
4144     }
4145
4146   /* Clear status variables */
4147   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
4148   tree_view->priv->rubber_band_extend = FALSE;
4149   tree_view->priv->rubber_band_modify = FALSE;
4150
4151   tree_view->priv->rubber_band_start_node = NULL;
4152   tree_view->priv->rubber_band_start_tree = NULL;
4153   tree_view->priv->rubber_band_end_node = NULL;
4154   tree_view->priv->rubber_band_end_tree = NULL;
4155 }
4156
4157 static void
4158 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
4159                                                  GtkRBTree   *start_tree,
4160                                                  GtkRBNode   *start_node,
4161                                                  GtkRBTree   *end_tree,
4162                                                  GtkRBNode   *end_node,
4163                                                  gboolean     select,
4164                                                  gboolean     skip_start,
4165                                                  gboolean     skip_end)
4166 {
4167   if (start_node == end_node)
4168     return;
4169
4170   /* We skip the first node and jump inside the loop */
4171   if (skip_start)
4172     goto skip_first;
4173
4174   do
4175     {
4176       /* Small optimization by assuming insensitive nodes are never
4177        * selected.
4178        */
4179       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4180         {
4181           GtkTreePath *path;
4182           gboolean selectable;
4183
4184           path = _gtk_tree_path_new_from_rbtree (start_tree, start_node);
4185           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
4186           gtk_tree_path_free (path);
4187
4188           if (!selectable)
4189             goto node_not_selectable;
4190         }
4191
4192       if (select)
4193         {
4194           if (tree_view->priv->rubber_band_extend)
4195             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4196           else if (tree_view->priv->rubber_band_modify)
4197             {
4198               /* Toggle the selection state */
4199               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4200                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4201               else
4202                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4203             }
4204           else
4205             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4206         }
4207       else
4208         {
4209           /* Mirror the above */
4210           if (tree_view->priv->rubber_band_extend)
4211             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4212           else if (tree_view->priv->rubber_band_modify)
4213             {
4214               /* Toggle the selection state */
4215               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4216                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4217               else
4218                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4219             }
4220           else
4221             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4222         }
4223
4224       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
4225
4226 node_not_selectable:
4227       if (start_node == end_node)
4228         break;
4229
4230 skip_first:
4231
4232       if (start_node->children)
4233         {
4234           start_tree = start_node->children;
4235           start_node = _gtk_rbtree_first (start_tree);
4236         }
4237       else
4238         {
4239           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
4240
4241           if (!start_tree)
4242             /* Ran out of tree */
4243             break;
4244         }
4245
4246       if (skip_end && start_node == end_node)
4247         break;
4248     }
4249   while (TRUE);
4250 }
4251
4252 static void
4253 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
4254 {
4255   GtkRBTree *start_tree, *end_tree;
4256   GtkRBNode *start_node, *end_node;
4257
4258   _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);
4259   _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);
4260
4261   /* Handle the start area first */
4262   if (!tree_view->priv->rubber_band_start_node)
4263     {
4264       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4265                                                        start_tree,
4266                                                        start_node,
4267                                                        end_tree,
4268                                                        end_node,
4269                                                        TRUE,
4270                                                        FALSE,
4271                                                        FALSE);
4272     }
4273   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
4274            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4275     {
4276       /* New node is above the old one; selection became bigger */
4277       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4278                                                        start_tree,
4279                                                        start_node,
4280                                                        tree_view->priv->rubber_band_start_tree,
4281                                                        tree_view->priv->rubber_band_start_node,
4282                                                        TRUE,
4283                                                        FALSE,
4284                                                        TRUE);
4285     }
4286   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
4287            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4288     {
4289       /* New node is below the old one; selection became smaller */
4290       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4291                                                        tree_view->priv->rubber_band_start_tree,
4292                                                        tree_view->priv->rubber_band_start_node,
4293                                                        start_tree,
4294                                                        start_node,
4295                                                        FALSE,
4296                                                        FALSE,
4297                                                        TRUE);
4298     }
4299
4300   tree_view->priv->rubber_band_start_tree = start_tree;
4301   tree_view->priv->rubber_band_start_node = start_node;
4302
4303   /* Next, handle the end area */
4304   if (!tree_view->priv->rubber_band_end_node)
4305     {
4306       /* In the event this happens, start_node was also NULL; this case is
4307        * handled above.
4308        */
4309     }
4310   else if (!end_node)
4311     {
4312       /* Find the last node in the tree */
4313       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
4314                                &end_tree, &end_node);
4315
4316       /* Selection reached end of the tree */
4317       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4318                                                        tree_view->priv->rubber_band_end_tree,
4319                                                        tree_view->priv->rubber_band_end_node,
4320                                                        end_tree,
4321                                                        end_node,
4322                                                        TRUE,
4323                                                        TRUE,
4324                                                        FALSE);
4325     }
4326   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
4327            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4328     {
4329       /* New node is below the old one; selection became bigger */
4330       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4331                                                        tree_view->priv->rubber_band_end_tree,
4332                                                        tree_view->priv->rubber_band_end_node,
4333                                                        end_tree,
4334                                                        end_node,
4335                                                        TRUE,
4336                                                        TRUE,
4337                                                        FALSE);
4338     }
4339   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
4340            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4341     {
4342       /* New node is above the old one; selection became smaller */
4343       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4344                                                        end_tree,
4345                                                        end_node,
4346                                                        tree_view->priv->rubber_band_end_tree,
4347                                                        tree_view->priv->rubber_band_end_node,
4348                                                        FALSE,
4349                                                        TRUE,
4350                                                        FALSE);
4351     }
4352
4353   tree_view->priv->rubber_band_end_tree = end_tree;
4354   tree_view->priv->rubber_band_end_node = end_node;
4355 }
4356
4357 static void
4358 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
4359 {
4360   gint x, y;
4361   GdkRectangle old_area;
4362   GdkRectangle new_area;
4363   GdkRectangle common;
4364   cairo_region_t *invalid_region;
4365
4366   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4367   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4368   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
4369   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
4370
4371   gdk_window_get_device_position (tree_view->priv->bin_window,
4372                                   gdk_device_manager_get_client_pointer (
4373                                     gdk_display_get_device_manager (
4374                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4375                                   &x, &y, NULL);
4376
4377   x = MAX (x, 0);
4378   y = MAX (y, 0) + tree_view->priv->dy;
4379
4380   new_area.x = MIN (tree_view->priv->press_start_x, x);
4381   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
4382   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
4383   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
4384
4385   invalid_region = cairo_region_create_rectangle (&old_area);
4386   cairo_region_union_rectangle (invalid_region, &new_area);
4387
4388   gdk_rectangle_intersect (&old_area, &new_area, &common);
4389   if (common.width > 2 && common.height > 2)
4390     {
4391       cairo_region_t *common_region;
4392
4393       /* make sure the border is invalidated */
4394       common.x += 1;
4395       common.y += 1;
4396       common.width -= 2;
4397       common.height -= 2;
4398
4399       common_region = cairo_region_create_rectangle (&common);
4400
4401       cairo_region_subtract (invalid_region, common_region);
4402       cairo_region_destroy (common_region);
4403     }
4404
4405   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
4406
4407   cairo_region_destroy (invalid_region);
4408
4409   tree_view->priv->rubber_band_x = x;
4410   tree_view->priv->rubber_band_y = y;
4411
4412   gtk_tree_view_update_rubber_band_selection (tree_view);
4413 }
4414
4415 static void
4416 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4417                                  cairo_t      *cr)
4418 {
4419   GdkRectangle rect;
4420   GtkStyleContext *context;
4421
4422   cairo_save (cr);
4423
4424   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4425
4426   gtk_style_context_save (context);
4427   gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND);
4428
4429   rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4430   rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4431   rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4432   rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4433
4434   gdk_cairo_rectangle (cr, &rect);
4435   cairo_clip (cr);
4436
4437   gtk_render_background (context, cr,
4438                          rect.x, rect.y,
4439                          rect.width, rect.height);
4440   gtk_render_frame (context, cr,
4441                     rect.x, rect.y,
4442                     rect.width, rect.height);
4443
4444   gtk_style_context_restore (context);
4445   cairo_restore (cr);
4446 }
4447
4448 static gboolean
4449 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4450                                  GdkEventMotion *event)
4451 {
4452   GtkTreeView *tree_view;
4453   GtkRBTree *tree;
4454   GtkRBNode *node;
4455   gint new_y;
4456
4457   tree_view = (GtkTreeView *) widget;
4458
4459   if (tree_view->priv->tree == NULL)
4460     return FALSE;
4461
4462   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4463     {
4464       gtk_grab_add (GTK_WIDGET (tree_view));
4465       gtk_tree_view_update_rubber_band (tree_view);
4466
4467       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4468     }
4469   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4470     {
4471       gtk_tree_view_update_rubber_band (tree_view);
4472
4473       add_scroll_timeout (tree_view);
4474     }
4475
4476   /* only check for an initiated drag when a button is pressed */
4477   if (tree_view->priv->pressed_button >= 0
4478       && !tree_view->priv->rubber_band_status)
4479     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4480
4481   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4482   if (new_y < 0)
4483     new_y = 0;
4484
4485   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4486
4487   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4488   if ((tree_view->priv->button_pressed_node != NULL) &&
4489       (tree_view->priv->button_pressed_node != node))
4490     node = NULL;
4491
4492   tree_view->priv->event_last_x = event->x;
4493   tree_view->priv->event_last_y = event->y;
4494
4495   prelight_or_select (tree_view, tree, node, event->x, event->y);
4496
4497   return TRUE;
4498 }
4499
4500 static gboolean
4501 gtk_tree_view_motion (GtkWidget      *widget,
4502                       GdkEventMotion *event)
4503 {
4504   GtkTreeView *tree_view;
4505
4506   tree_view = (GtkTreeView *) widget;
4507
4508   /* Resizing a column */
4509   if (tree_view->priv->in_column_resize)
4510     return gtk_tree_view_motion_resize_column (widget, event);
4511
4512   /* Drag column */
4513   if (tree_view->priv->in_column_drag)
4514     return gtk_tree_view_motion_drag_column (widget, event);
4515
4516   /* Sanity check it */
4517   if (event->window == tree_view->priv->bin_window)
4518     return gtk_tree_view_motion_bin_window (widget, event);
4519
4520   return FALSE;
4521 }
4522
4523 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4524  * the tree is empty.
4525  */
4526 static void
4527 invalidate_empty_focus (GtkTreeView *tree_view)
4528 {
4529   GdkRectangle area;
4530
4531   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
4532     return;
4533
4534   area.x = 0;
4535   area.y = 0;
4536   area.width = gdk_window_get_width (tree_view->priv->bin_window);
4537   area.height = gdk_window_get_height (tree_view->priv->bin_window);
4538   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4539 }
4540
4541 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4542  * is empty.
4543  */
4544 static void
4545 draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr)
4546 {
4547   GtkWidget *widget = GTK_WIDGET (tree_view);
4548   gint w, h;
4549
4550   if (!gtk_widget_has_visible_focus (widget))
4551     return;
4552
4553   w = gdk_window_get_width (tree_view->priv->bin_window) - 2;
4554   h = gdk_window_get_height (tree_view->priv->bin_window) - 2;
4555
4556   if (w > 0 && h > 0)
4557     {
4558       GtkStyleContext *context;
4559
4560       context = gtk_widget_get_style_context (widget);
4561
4562       gtk_render_focus (context, cr, 1, 1, w, h);
4563     }
4564 }
4565
4566 typedef enum {
4567   GTK_TREE_VIEW_GRID_LINE,
4568   GTK_TREE_VIEW_TREE_LINE,
4569   GTK_TREE_VIEW_FOREGROUND_LINE
4570 } GtkTreeViewLineType;
4571
4572 static void
4573 gtk_tree_view_draw_line (GtkTreeView         *tree_view,
4574                          cairo_t             *cr,
4575                          GtkTreeViewLineType  type,
4576                          int                  x1,
4577                          int                  y1,
4578                          int                  x2,
4579                          int                  y2)
4580 {
4581   cairo_save (cr);
4582
4583   switch (type)
4584     {
4585     case GTK_TREE_VIEW_TREE_LINE:
4586       cairo_set_source_rgb (cr, 0, 0, 0);
4587       cairo_set_line_width (cr, tree_view->priv->tree_line_width);
4588       if (tree_view->priv->tree_line_dashes[0])
4589         cairo_set_dash (cr,
4590                         tree_view->priv->tree_line_dashes,
4591                         2, 0.5);
4592       break;
4593     case GTK_TREE_VIEW_GRID_LINE:
4594       cairo_set_source_rgb (cr, 0, 0, 0);
4595       cairo_set_line_width (cr, tree_view->priv->grid_line_width);
4596       if (tree_view->priv->grid_line_dashes[0])
4597         cairo_set_dash (cr,
4598                         tree_view->priv->grid_line_dashes,
4599                         2, 0.5);
4600       break;
4601     default:
4602       g_assert_not_reached ();
4603       /* fall through */
4604     case GTK_TREE_VIEW_FOREGROUND_LINE:
4605       {
4606         GtkStyleContext *context;
4607         GtkStateFlags state;
4608         GdkRGBA color;
4609
4610         context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4611         state = gtk_widget_get_state_flags (GTK_WIDGET (tree_view));
4612
4613         cairo_set_line_width (cr, 1.0);
4614         gtk_style_context_get_color (context, state, &color);
4615         gdk_cairo_set_source_rgba (cr, &color);
4616       }
4617
4618       break;
4619     }
4620
4621   cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
4622   cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
4623   cairo_stroke (cr);
4624
4625   cairo_restore (cr);
4626 }
4627
4628 static void
4629 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4630                                cairo_t        *cr,
4631                                gint            n_visible_columns)
4632 {
4633   GList *list = tree_view->priv->columns;
4634   gint i = 0;
4635   gint current_x = 0;
4636
4637   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4638       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4639     return;
4640
4641   /* Only draw the lines for visible rows and columns */
4642   for (list = tree_view->priv->columns; list; list = list->next, i++)
4643     {
4644       GtkTreeViewColumn *column = list->data;
4645
4646       /* We don't want a line for the last column */
4647       if (i == n_visible_columns - 1)
4648         break;
4649
4650       if (!gtk_tree_view_column_get_visible (column))
4651         continue;
4652
4653       current_x += gtk_tree_view_column_get_width (column);
4654
4655       gtk_tree_view_draw_line (tree_view, cr,
4656                                GTK_TREE_VIEW_GRID_LINE,
4657                                current_x - 1, 0,
4658                                current_x - 1, tree_view->priv->height);
4659     }
4660 }
4661
4662 /* Warning: Very scary function.
4663  * Modify at your own risk
4664  *
4665  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4666  * FIXME: It's not...
4667  */
4668 static gboolean
4669 gtk_tree_view_bin_draw (GtkWidget      *widget,
4670                         cairo_t        *cr)
4671 {
4672   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4673   GtkTreePath *path;
4674   GtkRBTree *tree;
4675   GList *list;
4676   GtkRBNode *node;
4677   GtkRBNode *drag_highlight = NULL;
4678   GtkRBTree *drag_highlight_tree = NULL;
4679   GtkTreeIter iter;
4680   gint new_y;
4681   gint y_offset, cell_offset;
4682   gint max_height;
4683   gint depth;
4684   GdkRectangle background_area;
4685   GdkRectangle cell_area;
4686   GdkRectangle clip;
4687   guint flags;
4688   gint highlight_x;
4689   gint expander_cell_width;
4690   gint bin_window_width;
4691   gint bin_window_height;
4692   GtkTreePath *drag_dest_path;
4693   GList *first_column, *last_column;
4694   gint vertical_separator;
4695   gint horizontal_separator;
4696   gboolean allow_rules;
4697   gboolean has_can_focus_cell;
4698   gboolean rtl;
4699   gint n_visible_columns;
4700   gint grid_line_width;
4701   gboolean draw_vgrid_lines, draw_hgrid_lines;
4702   GtkStyleContext *context;
4703   gboolean parity;
4704
4705   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4706   context = gtk_widget_get_style_context (widget);
4707
4708   gtk_widget_style_get (widget,
4709                         "horizontal-separator", &horizontal_separator,
4710                         "vertical-separator", &vertical_separator,
4711                         "allow-rules", &allow_rules,
4712                         NULL);
4713
4714   if (tree_view->priv->tree == NULL)
4715     {
4716       draw_empty_focus (tree_view, cr);
4717       return TRUE;
4718     }
4719
4720   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
4721   bin_window_height = gdk_window_get_height (tree_view->priv->bin_window);
4722   cairo_rectangle (cr, 0, 0, bin_window_width, bin_window_height);
4723   cairo_clip (cr);
4724   if (!gdk_cairo_get_clip_rectangle (cr, &clip))
4725     return TRUE;
4726
4727   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, clip.y);
4728
4729   if (new_y < 0)
4730     new_y = 0;
4731   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4732
4733   if (tree_view->priv->height < bin_window_height)
4734     {
4735       gtk_style_context_save (context);
4736       gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4737
4738       gtk_render_background (context, cr,
4739                              0, tree_view->priv->height,
4740                              bin_window_width,
4741                              bin_window_height - tree_view->priv->height);
4742
4743       gtk_style_context_restore (context);
4744     }
4745
4746   if (node == NULL)
4747     return TRUE;
4748
4749   /* find the path for the node */
4750   path = _gtk_tree_path_new_from_rbtree (tree, node);
4751   gtk_tree_model_get_iter (tree_view->priv->model,
4752                            &iter,
4753                            path);
4754   depth = gtk_tree_path_get_depth (path);
4755   gtk_tree_path_free (path);
4756
4757   drag_dest_path = NULL;
4758
4759   if (tree_view->priv->drag_dest_row)
4760     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4761
4762   if (drag_dest_path)
4763     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4764                               &drag_highlight_tree, &drag_highlight);
4765
4766   draw_vgrid_lines =
4767     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4768     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4769   draw_hgrid_lines =
4770     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4771     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4772
4773   if (draw_vgrid_lines || draw_hgrid_lines)
4774     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4775
4776   n_visible_columns = 0;
4777   for (list = tree_view->priv->columns; list; list = list->next)
4778     {
4779       if (!gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
4780         continue;
4781       n_visible_columns ++;
4782     }
4783
4784   /* Find the last column */
4785   for (last_column = g_list_last (tree_view->priv->columns);
4786        last_column &&
4787        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
4788        last_column = last_column->prev)
4789     ;
4790
4791   /* and the first */
4792   for (first_column = g_list_first (tree_view->priv->columns);
4793        first_column &&
4794        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
4795        first_column = first_column->next)
4796     ;
4797
4798   /* Actually process the expose event.  To do this, we want to
4799    * start at the first node of the event, and walk the tree in
4800    * order, drawing each successive node.
4801    */
4802
4803   parity = !(_gtk_rbtree_node_get_index (tree, node) % 2);
4804
4805   do
4806     {
4807       gboolean is_separator = FALSE;
4808       gboolean is_first = FALSE;
4809       gboolean is_last = FALSE;
4810       gint n_col = 0;
4811
4812       parity = !parity;
4813       is_separator = row_is_separator (tree_view, &iter, NULL);
4814
4815       max_height = gtk_tree_view_get_row_height (tree_view, node);
4816
4817       cell_offset = 0;
4818       highlight_x = 0; /* should match x coord of first cell */
4819       expander_cell_width = 0;
4820
4821       background_area.y = y_offset + clip.y;
4822       background_area.height = max_height;
4823
4824       flags = 0;
4825
4826       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4827         flags |= GTK_CELL_RENDERER_PRELIT;
4828
4829       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4830         flags |= GTK_CELL_RENDERER_SELECTED;
4831
4832       /* we *need* to set cell data on all cells before the call
4833        * to _has_can_focus_cell, else _has_can_focus_cell() does not
4834        * return a correct value.
4835        */
4836       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4837            list;
4838            list = (rtl ? list->prev : list->next))
4839         {
4840           GtkTreeViewColumn *column = list->data;
4841           gtk_tree_view_column_cell_set_cell_data (column,
4842                                                    tree_view->priv->model,
4843                                                    &iter,
4844                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4845                                                    node->children?TRUE:FALSE);
4846         }
4847
4848       has_can_focus_cell = gtk_tree_view_has_can_focus_cell (tree_view);
4849
4850       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4851            list;
4852            list = (rtl ? list->prev : list->next))
4853         {
4854           GtkTreeViewColumn *column = list->data;
4855           GtkRegionFlags row_flags = 0, column_flags = 0;
4856           GtkStateFlags state = 0;
4857           gint width;
4858           gboolean draw_focus;
4859
4860           if (!gtk_tree_view_column_get_visible (column))
4861             continue;
4862
4863           n_col++;
4864           width = gtk_tree_view_column_get_width (column);
4865
4866           if (cell_offset > clip.x + clip.width ||
4867               cell_offset + width < clip.x)
4868             {
4869               cell_offset += width;
4870               continue;
4871             }
4872
4873           if (gtk_tree_view_column_get_sort_indicator (column))
4874             flags |= GTK_CELL_RENDERER_SORTED;
4875           else
4876             flags &= ~GTK_CELL_RENDERER_SORTED;
4877
4878           if (tree_view->priv->cursor_node == node)
4879             flags |= GTK_CELL_RENDERER_FOCUSED;
4880           else
4881             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4882
4883           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
4884             flags |= GTK_CELL_RENDERER_EXPANDABLE;
4885           else
4886             flags &= ~GTK_CELL_RENDERER_EXPANDABLE;
4887
4888           if (node->children)
4889             flags |= GTK_CELL_RENDERER_EXPANDED;
4890           else
4891             flags &= ~GTK_CELL_RENDERER_EXPANDED;
4892
4893           background_area.x = cell_offset;
4894           background_area.width = width;
4895
4896           cell_area = background_area;
4897           cell_area.y += vertical_separator / 2;
4898           cell_area.x += horizontal_separator / 2;
4899           cell_area.height -= vertical_separator;
4900           cell_area.width -= horizontal_separator;
4901
4902           if (draw_vgrid_lines)
4903             {
4904               if (list == first_column)
4905                 {
4906                   cell_area.width -= grid_line_width / 2;
4907                 }
4908               else if (list == last_column)
4909                 {
4910                   cell_area.x += grid_line_width / 2;
4911                   cell_area.width -= grid_line_width / 2;
4912                 }
4913               else
4914                 {
4915                   cell_area.x += grid_line_width / 2;
4916                   cell_area.width -= grid_line_width;
4917                 }
4918             }
4919
4920           if (draw_hgrid_lines)
4921             {
4922               cell_area.y += grid_line_width / 2;
4923               cell_area.height -= grid_line_width;
4924             }
4925
4926           if (!gdk_rectangle_intersect (&clip, &background_area, NULL))
4927             {
4928               cell_offset += gtk_tree_view_column_get_width (column);
4929               continue;
4930             }
4931
4932           gtk_tree_view_column_cell_set_cell_data (column,
4933                                                    tree_view->priv->model,
4934                                                    &iter,
4935                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4936                                                    node->children?TRUE:FALSE);
4937
4938           /* Select the detail for drawing the cell.  relevant
4939            * factors are parity, sortedness, and whether to
4940            * display rules.
4941            */
4942           if (allow_rules && tree_view->priv->has_rules)
4943             {
4944               if (parity)
4945                 row_flags |= GTK_REGION_ODD;
4946               else
4947                 row_flags |= GTK_REGION_EVEN;
4948             }
4949
4950           if ((flags & GTK_CELL_RENDERER_SORTED) &&
4951               n_visible_columns >= 3)
4952             column_flags |= GTK_REGION_SORTED;
4953
4954           is_first = (rtl ? !list->next : !list->prev);
4955           is_last = (rtl ? !list->prev : !list->next);
4956
4957           if (is_first)
4958             column_flags |= GTK_REGION_FIRST;
4959
4960           if (is_last)
4961             column_flags |= GTK_REGION_LAST;
4962
4963           if ((n_col % 2) == 0)
4964             column_flags |= GTK_REGION_EVEN;
4965           else
4966             column_flags |= GTK_REGION_ODD;
4967
4968           gtk_style_context_save (context);
4969
4970           state = gtk_cell_renderer_get_state (NULL, widget, flags);
4971           gtk_style_context_set_state (context, state);
4972
4973           gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4974           gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
4975           gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, column_flags);
4976
4977           if (node == tree_view->priv->cursor_node && has_can_focus_cell
4978               && ((column == tree_view->priv->focus_column
4979                    && tree_view->priv->draw_keyfocus &&
4980                    gtk_widget_has_visible_focus (widget))
4981                   || (column == tree_view->priv->edited_column)))
4982             draw_focus = TRUE;
4983           else
4984             draw_focus = FALSE;
4985
4986           /* Draw background */
4987           gtk_render_background (context, cr,
4988                                  background_area.x,
4989                                  background_area.y,
4990                                  background_area.width,
4991                                  background_area.height);
4992
4993           /* Draw frame */
4994           gtk_render_frame (context, cr,
4995                             background_area.x,
4996                             background_area.y,
4997                             background_area.width,
4998                             background_area.height);
4999
5000           if (gtk_tree_view_is_expander_column (tree_view, column))
5001             {
5002               if (!rtl)
5003                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
5004               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
5005
5006               if (gtk_tree_view_draw_expanders (tree_view))
5007                 {
5008                   if (!rtl)
5009                     cell_area.x += depth * tree_view->priv->expander_size;
5010                   cell_area.width -= depth * tree_view->priv->expander_size;
5011                 }
5012
5013               /* If we have an expander column, the highlight underline
5014                * starts with that column, so that it indicates which
5015                * level of the tree we're dropping at.
5016                */
5017               highlight_x = cell_area.x;
5018               expander_cell_width = cell_area.width;
5019
5020               if (is_separator)
5021                 {
5022                   gtk_style_context_save (context);
5023                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5024
5025                   gtk_render_line (context, cr,
5026                                    cell_area.x,
5027                                    cell_area.y + cell_area.height / 2,
5028                                    cell_area.x + cell_area.width,
5029                                    cell_area.y + cell_area.height / 2);
5030
5031                   gtk_style_context_restore (context);
5032                 }
5033               else
5034                 {
5035                   _gtk_tree_view_column_cell_render (column,
5036                                                      cr,
5037                                                      &background_area,
5038                                                      &cell_area,
5039                                                      flags,
5040                                                      draw_focus);
5041                 }
5042
5043               if (gtk_tree_view_draw_expanders (tree_view)
5044                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
5045                 {
5046                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
5047                                             cr,
5048                                             tree,
5049                                             node);
5050                 }
5051             }
5052           else
5053             {
5054               if (is_separator)
5055                 {
5056                   gtk_style_context_save (context);
5057                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5058
5059                   gtk_render_line (context, cr,
5060                                    cell_area.x,
5061                                    cell_area.y + cell_area.height / 2,
5062                                    cell_area.x + cell_area.width,
5063                                    cell_area.y + cell_area.height / 2);
5064
5065                   gtk_style_context_restore (context);
5066                 }
5067               else
5068                 _gtk_tree_view_column_cell_render (column,
5069                                                    cr,
5070                                                    &background_area,
5071                                                    &cell_area,
5072                                                    flags,
5073                                                    draw_focus);
5074             }
5075
5076           if (draw_hgrid_lines)
5077             {
5078               if (background_area.y > 0)
5079                 gtk_tree_view_draw_line (tree_view, cr,
5080                                          GTK_TREE_VIEW_GRID_LINE,
5081                                          background_area.x, background_area.y,
5082                                          background_area.x + background_area.width,
5083                                          background_area.y);
5084
5085               if (y_offset + max_height >= clip.height)
5086                 gtk_tree_view_draw_line (tree_view, cr,
5087                                          GTK_TREE_VIEW_GRID_LINE,
5088                                          background_area.x, background_area.y + max_height,
5089                                          background_area.x + background_area.width,
5090                                          background_area.y + max_height);
5091             }
5092
5093           if (gtk_tree_view_is_expander_column (tree_view, column) &&
5094               tree_view->priv->tree_lines_enabled)
5095             {
5096               gint x = background_area.x;
5097               gint mult = rtl ? -1 : 1;
5098               gint y0 = background_area.y;
5099               gint y1 = background_area.y + background_area.height/2;
5100               gint y2 = background_area.y + background_area.height;
5101
5102               if (rtl)
5103                 x += background_area.width - 1;
5104
5105               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
5106                   && depth > 1)
5107                 {
5108                   gtk_tree_view_draw_line (tree_view, cr,
5109                                            GTK_TREE_VIEW_TREE_LINE,
5110                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5111                                            y1,
5112                                            x + tree_view->priv->expander_size * (depth - 1.1) * mult,
5113                                            y1);
5114                 }
5115               else if (depth > 1)
5116                 {
5117                   gtk_tree_view_draw_line (tree_view, cr,
5118                                            GTK_TREE_VIEW_TREE_LINE,
5119                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5120                                            y1,
5121                                            x + tree_view->priv->expander_size * (depth - 0.5) * mult,
5122                                            y1);
5123                 }
5124
5125               if (depth > 1)
5126                 {
5127                   gint i;
5128                   GtkRBNode *tmp_node;
5129                   GtkRBTree *tmp_tree;
5130
5131                   if (!_gtk_rbtree_next (tree, node))
5132                     gtk_tree_view_draw_line (tree_view, cr,
5133                                              GTK_TREE_VIEW_TREE_LINE,
5134                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5135                                              y0,
5136                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5137                                              y1);
5138                   else
5139                     gtk_tree_view_draw_line (tree_view, cr,
5140                                              GTK_TREE_VIEW_TREE_LINE,
5141                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5142                                              y0,
5143                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5144                                              y2);
5145
5146                   tmp_node = tree->parent_node;
5147                   tmp_tree = tree->parent_tree;
5148
5149                   for (i = depth - 2; i > 0; i--)
5150                     {
5151                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
5152                         gtk_tree_view_draw_line (tree_view, cr,
5153                                                  GTK_TREE_VIEW_TREE_LINE,
5154                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
5155                                                  y0,
5156                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
5157                                                  y2);
5158
5159                       tmp_node = tmp_tree->parent_node;
5160                       tmp_tree = tmp_tree->parent_tree;
5161                     }
5162                 }
5163             }
5164
5165           gtk_style_context_restore (context);
5166           cell_offset += gtk_tree_view_column_get_width (column);
5167         }
5168
5169       if (node == drag_highlight)
5170         {
5171           /* Draw indicator for the drop
5172            */
5173           gint highlight_y = -1;
5174           GtkRBTree *tree = NULL;
5175           GtkRBNode *node = NULL;
5176
5177           gtk_style_context_save (context);
5178           gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND);
5179
5180           switch (tree_view->priv->drag_dest_pos)
5181             {
5182             case GTK_TREE_VIEW_DROP_BEFORE:
5183               highlight_y = background_area.y - 1;
5184               if (highlight_y < 0)
5185                       highlight_y = 0;
5186               break;
5187
5188             case GTK_TREE_VIEW_DROP_AFTER:
5189               highlight_y = background_area.y + background_area.height - 1;
5190               break;
5191
5192             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
5193             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
5194               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
5195
5196               if (tree == NULL)
5197                 break;
5198
5199               gtk_render_frame (context, cr,
5200                                 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node),
5201                                 gdk_window_get_width (tree_view->priv->bin_window),
5202                                 gtk_tree_view_get_row_height (tree_view, node));
5203               break;
5204             }
5205
5206           if (highlight_y >= 0)
5207             {
5208               gtk_tree_view_draw_line (tree_view, cr,
5209                                        GTK_TREE_VIEW_FOREGROUND_LINE,
5210                                        rtl ? highlight_x + expander_cell_width : highlight_x,
5211                                        highlight_y,
5212                                        rtl ? 0 : bin_window_width,
5213                                        highlight_y);
5214             }
5215
5216           gtk_style_context_restore (context);
5217         }
5218
5219       /* draw the big row-spanning focus rectangle, if needed */
5220       if (!has_can_focus_cell && node == tree_view->priv->cursor_node &&
5221           tree_view->priv->draw_keyfocus &&
5222           gtk_widget_has_visible_focus (widget))
5223         {
5224           gint tmp_y, tmp_height;
5225           GtkStateFlags focus_rect_state = 0;
5226
5227           gtk_style_context_save (context);
5228
5229           focus_rect_state = gtk_cell_renderer_get_state (NULL, widget, flags);
5230           gtk_style_context_set_state (context, focus_rect_state);
5231
5232           if (draw_hgrid_lines)
5233             {
5234               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node) + grid_line_width / 2;
5235               tmp_height = gtk_tree_view_get_row_height (tree_view, node) - grid_line_width;
5236             }
5237           else
5238             {
5239               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
5240               tmp_height = gtk_tree_view_get_row_height (tree_view, node);
5241             }
5242
5243           gtk_render_focus (context, cr,
5244                             0, tmp_y,
5245                             gdk_window_get_width (tree_view->priv->bin_window),
5246                             tmp_height);
5247
5248           gtk_style_context_restore (context);
5249         }
5250
5251       y_offset += max_height;
5252       if (node->children)
5253         {
5254           GtkTreeIter parent = iter;
5255           gboolean has_child;
5256
5257           tree = node->children;
5258           node = _gtk_rbtree_first (tree);
5259
5260           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
5261                                                     &iter,
5262                                                     &parent);
5263           depth++;
5264
5265           /* Sanity Check! */
5266           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
5267         }
5268       else
5269         {
5270           gboolean done = FALSE;
5271
5272           do
5273             {
5274               node = _gtk_rbtree_next (tree, node);
5275               if (node != NULL)
5276                 {
5277                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
5278                   done = TRUE;
5279
5280                   /* Sanity Check! */
5281                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
5282                 }
5283               else
5284                 {
5285                   GtkTreeIter parent_iter = iter;
5286                   gboolean has_parent;
5287
5288                   node = tree->parent_node;
5289                   tree = tree->parent_tree;
5290                   if (tree == NULL)
5291                     /* we should go to done to free some memory */
5292                     goto done;
5293                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
5294                                                            &iter,
5295                                                            &parent_iter);
5296                   depth--;
5297
5298                   /* Sanity check */
5299                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
5300                 }
5301             }
5302           while (!done);
5303         }
5304     }
5305   while (y_offset < clip.height);
5306
5307 done:
5308   gtk_tree_view_draw_grid_lines (tree_view, cr, n_visible_columns);
5309
5310   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
5311     gtk_tree_view_paint_rubber_band (tree_view, cr);
5312
5313   if (drag_dest_path)
5314     gtk_tree_path_free (drag_dest_path);
5315
5316   return FALSE;
5317 }
5318
5319 static gboolean
5320 gtk_tree_view_draw (GtkWidget *widget,
5321                     cairo_t   *cr)
5322 {
5323   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5324   GtkWidget   *button;
5325
5326   if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
5327     {
5328       GtkStyleContext *context;
5329       GList *tmp_list;
5330
5331       context = gtk_widget_get_style_context (widget);
5332
5333       cairo_save (cr);
5334
5335       gtk_style_context_save (context);
5336       gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
5337
5338       gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
5339
5340       gtk_tree_view_bin_draw (widget, cr);
5341
5342       gtk_style_context_restore (context);
5343       cairo_restore (cr);
5344
5345       /* We can't just chain up to Container::draw as it will try to send the
5346        * event to the headers, so we handle propagating it to our children
5347        * (eg. widgets being edited) ourselves.
5348        */
5349       tmp_list = tree_view->priv->children;
5350       while (tmp_list)
5351         {
5352           GtkTreeViewChild *child = tmp_list->data;
5353           tmp_list = tmp_list->next;
5354
5355           gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
5356         }
5357     }
5358
5359   if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
5360     {
5361       GList *list;
5362
5363       for (list = tree_view->priv->columns; list != NULL; list = list->next)
5364         {
5365           GtkTreeViewColumn *column = list->data;
5366
5367           if (column == tree_view->priv->drag_column)
5368             continue;
5369
5370           if (gtk_tree_view_column_get_visible (column))
5371             {
5372               button = gtk_tree_view_column_get_button (column);
5373               gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5374                                             button, cr);
5375             }
5376         }
5377     }
5378
5379   if (tree_view->priv->drag_window &&
5380       gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
5381     {
5382       button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
5383       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5384                                     button, cr);
5385     }
5386
5387   return FALSE;
5388 }
5389
5390 enum
5391 {
5392   DROP_HOME,
5393   DROP_RIGHT,
5394   DROP_LEFT,
5395   DROP_END
5396 };
5397
5398 /* returns 0x1 when no column has been found -- yes it's hackish */
5399 static GtkTreeViewColumn *
5400 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5401                                GtkTreeViewColumn *column,
5402                                gint               drop_position)
5403 {
5404   GtkTreeViewColumn *left_column = NULL;
5405   GtkTreeViewColumn *cur_column = NULL;
5406   GList *tmp_list;
5407
5408   if (!gtk_tree_view_column_get_reorderable (column))
5409     return (GtkTreeViewColumn *)0x1;
5410
5411   switch (drop_position)
5412     {
5413       case DROP_HOME:
5414         /* find first column where we can drop */
5415         tmp_list = tree_view->priv->columns;
5416         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5417           return (GtkTreeViewColumn *)0x1;
5418
5419         while (tmp_list)
5420           {
5421             g_assert (tmp_list);
5422
5423             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5424             tmp_list = tmp_list->next;
5425
5426             if (left_column &&
5427                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5428               continue;
5429
5430             if (!tree_view->priv->column_drop_func)
5431               return left_column;
5432
5433             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5434               {
5435                 left_column = cur_column;
5436                 continue;
5437               }
5438
5439             return left_column;
5440           }
5441
5442         if (!tree_view->priv->column_drop_func)
5443           return left_column;
5444
5445         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5446           return left_column;
5447         else
5448           return (GtkTreeViewColumn *)0x1;
5449         break;
5450
5451       case DROP_RIGHT:
5452         /* find first column after column where we can drop */
5453         tmp_list = tree_view->priv->columns;
5454
5455         for (; tmp_list; tmp_list = tmp_list->next)
5456           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5457             break;
5458
5459         if (!tmp_list || !tmp_list->next)
5460           return (GtkTreeViewColumn *)0x1;
5461
5462         tmp_list = tmp_list->next;
5463         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5464         tmp_list = tmp_list->next;
5465
5466         while (tmp_list)
5467           {
5468             g_assert (tmp_list);
5469
5470             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5471             tmp_list = tmp_list->next;
5472
5473             if (left_column &&
5474                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5475               {
5476                 left_column = cur_column;
5477                 if (tmp_list)
5478                   tmp_list = tmp_list->next;
5479                 continue;
5480               }
5481
5482             if (!tree_view->priv->column_drop_func)
5483               return left_column;
5484
5485             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5486               {
5487                 left_column = cur_column;
5488                 continue;
5489               }
5490
5491             return left_column;
5492           }
5493
5494         if (!tree_view->priv->column_drop_func)
5495           return left_column;
5496
5497         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5498           return left_column;
5499         else
5500           return (GtkTreeViewColumn *)0x1;
5501         break;
5502
5503       case DROP_LEFT:
5504         /* find first column before column where we can drop */
5505         tmp_list = tree_view->priv->columns;
5506
5507         for (; tmp_list; tmp_list = tmp_list->next)
5508           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5509             break;
5510
5511         if (!tmp_list || !tmp_list->prev)
5512           return (GtkTreeViewColumn *)0x1;
5513
5514         tmp_list = tmp_list->prev;
5515         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5516         tmp_list = tmp_list->prev;
5517
5518         while (tmp_list)
5519           {
5520             g_assert (tmp_list);
5521
5522             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5523
5524             if (left_column &&
5525                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5526               {
5527                 /*if (!tmp_list->prev)
5528                   return (GtkTreeViewColumn *)0x1;
5529                   */
5530 /*
5531                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5532                 tmp_list = tmp_list->prev->prev;
5533                 continue;*/
5534
5535                 cur_column = left_column;
5536                 if (tmp_list)
5537                   tmp_list = tmp_list->prev;
5538                 continue;
5539               }
5540
5541             if (!tree_view->priv->column_drop_func)
5542               return left_column;
5543
5544             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5545               return left_column;
5546
5547             cur_column = left_column;
5548             tmp_list = tmp_list->prev;
5549           }
5550
5551         if (!tree_view->priv->column_drop_func)
5552           return NULL;
5553
5554         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5555           return NULL;
5556         else
5557           return (GtkTreeViewColumn *)0x1;
5558         break;
5559
5560       case DROP_END:
5561         /* same as DROP_HOME case, but doing it backwards */
5562         tmp_list = g_list_last (tree_view->priv->columns);
5563         cur_column = NULL;
5564
5565         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5566           return (GtkTreeViewColumn *)0x1;
5567
5568         while (tmp_list)
5569           {
5570             g_assert (tmp_list);
5571
5572             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5573
5574             if (left_column &&
5575                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5576               {
5577                 cur_column = left_column;
5578                 tmp_list = tmp_list->prev;
5579               }
5580
5581             if (!tree_view->priv->column_drop_func)
5582               return left_column;
5583
5584             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5585               return left_column;
5586
5587             cur_column = left_column;
5588             tmp_list = tmp_list->prev;
5589           }
5590
5591         if (!tree_view->priv->column_drop_func)
5592           return NULL;
5593
5594         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5595           return NULL;
5596         else
5597           return (GtkTreeViewColumn *)0x1;
5598         break;
5599     }
5600
5601   return (GtkTreeViewColumn *)0x1;
5602 }
5603
5604 static gboolean
5605 gtk_tree_view_key_press (GtkWidget   *widget,
5606                          GdkEventKey *event)
5607 {
5608   GtkTreeView *tree_view = (GtkTreeView *) widget;
5609   GtkWidget   *button;
5610
5611   if (tree_view->priv->rubber_band_status)
5612     {
5613       if (event->keyval == GDK_KEY_Escape)
5614         gtk_tree_view_stop_rubber_band (tree_view);
5615
5616       return TRUE;
5617     }
5618
5619   if (tree_view->priv->in_column_drag)
5620     {
5621       if (event->keyval == GDK_KEY_Escape)
5622         {
5623           tree_view->priv->cur_reorder = NULL;
5624           gtk_tree_view_button_release_drag_column (widget, NULL);
5625         }
5626       return TRUE;
5627     }
5628
5629   if (tree_view->priv->headers_visible)
5630     {
5631       GList *focus_column;
5632       gboolean rtl;
5633
5634       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5635
5636       for (focus_column = tree_view->priv->columns;
5637            focus_column;
5638            focus_column = focus_column->next)
5639         {
5640           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5641
5642           button = gtk_tree_view_column_get_button (column);
5643           if (gtk_widget_has_focus (button))
5644             break;
5645         }
5646
5647       if (focus_column &&
5648           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5649           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5650            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right))
5651         {
5652           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5653           gint max_width, min_width;
5654
5655           if (!gtk_tree_view_column_get_resizable (column))
5656             {
5657               gtk_widget_error_bell (widget);
5658               return TRUE;
5659             }
5660
5661           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5662               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5663             {
5664               GtkRequisition button_req;
5665               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5666               gint new_width;
5667
5668               button = gtk_tree_view_column_get_button (column);
5669
5670               gtk_widget_get_preferred_size (button, &button_req, NULL);
5671
5672               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5673               new_width -= 2;
5674               if (new_width < 0)
5675                 new_width = 0;
5676
5677               _gtk_tree_view_column_set_resized_width (column, new_width);
5678
5679               min_width = gtk_tree_view_column_get_min_width (column);
5680               if (min_width == -1)
5681                 new_width = MAX (button_req.width, new_width);
5682               else
5683                 {
5684                   new_width = MAX (min_width, new_width);
5685                 }
5686
5687               max_width = gtk_tree_view_column_get_max_width (column);
5688               if (max_width != -1)
5689                 new_width = MIN (new_width, max_width);
5690
5691               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5692
5693               if (new_width != old_width)
5694                 {
5695                   _gtk_tree_view_column_set_resized_width (column, new_width);
5696                   gtk_widget_queue_resize (widget);
5697                 }
5698               else
5699                 gtk_widget_error_bell (widget);
5700             }
5701           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5702                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5703             {
5704               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5705               gint new_width;
5706
5707               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5708               new_width += 2;
5709
5710               max_width = gtk_tree_view_column_get_max_width (column);
5711               if (max_width != -1)
5712                 new_width = MIN (new_width, max_width);
5713
5714               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5715
5716               if (new_width != old_width)
5717                 {
5718                   _gtk_tree_view_column_set_resized_width (column, new_width);
5719                   gtk_widget_queue_resize (widget);
5720                 }
5721               else
5722                 gtk_widget_error_bell (widget);
5723             }
5724
5725           return TRUE;
5726         }
5727
5728       if (focus_column &&
5729           (event->state & GDK_MOD1_MASK) &&
5730           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5731            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right
5732            || event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home
5733            || event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End))
5734         {
5735           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5736
5737           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5738               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5739             {
5740               GtkTreeViewColumn *col;
5741               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5742               if (col != (GtkTreeViewColumn *)0x1)
5743                 gtk_tree_view_move_column_after (tree_view, column, col);
5744               else
5745                 gtk_widget_error_bell (widget);
5746             }
5747           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5748                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5749             {
5750               GtkTreeViewColumn *col;
5751               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5752               if (col != (GtkTreeViewColumn *)0x1)
5753                 gtk_tree_view_move_column_after (tree_view, column, col);
5754               else
5755                 gtk_widget_error_bell (widget);
5756             }
5757           else if (event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home)
5758             {
5759               GtkTreeViewColumn *col;
5760               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5761               if (col != (GtkTreeViewColumn *)0x1)
5762                 gtk_tree_view_move_column_after (tree_view, column, col);
5763               else
5764                 gtk_widget_error_bell (widget);
5765             }
5766           else if (event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
5767             {
5768               GtkTreeViewColumn *col;
5769               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
5770               if (col != (GtkTreeViewColumn *)0x1)
5771                 gtk_tree_view_move_column_after (tree_view, column, col);
5772               else
5773                 gtk_widget_error_bell (widget);
5774             }
5775
5776           return TRUE;
5777         }
5778     }
5779
5780   /* Chain up to the parent class.  It handles the keybindings. */
5781   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5782     return TRUE;
5783
5784   if (tree_view->priv->search_entry_avoid_unhandled_binding)
5785     {
5786       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
5787       return FALSE;
5788     }
5789
5790   /* We pass the event to the search_entry.  If its text changes, then we start
5791    * the typeahead find capabilities. */
5792   if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
5793       && tree_view->priv->enable_search
5794       && !tree_view->priv->search_custom_entry_set)
5795     {
5796       GdkEvent *new_event;
5797       char *old_text;
5798       const char *new_text;
5799       gboolean retval;
5800       GdkScreen *screen;
5801       gboolean text_modified;
5802       gulong popup_menu_id;
5803
5804       gtk_tree_view_ensure_interactive_directory (tree_view);
5805
5806       /* Make a copy of the current text */
5807       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5808       new_event = gdk_event_copy ((GdkEvent *) event);
5809       g_object_unref (((GdkEventKey *) new_event)->window);
5810       ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
5811       gtk_widget_realize (tree_view->priv->search_window);
5812
5813       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5814                                         "popup-menu", G_CALLBACK (gtk_true),
5815                                         NULL);
5816
5817       /* Move the entry off screen */
5818       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5819       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5820                        gdk_screen_get_width (screen) + 1,
5821                        gdk_screen_get_height (screen) + 1);
5822       gtk_widget_show (tree_view->priv->search_window);
5823
5824       /* Send the event to the window.  If the preedit_changed signal is emitted
5825        * during this event, we will set priv->imcontext_changed  */
5826       tree_view->priv->imcontext_changed = FALSE;
5827       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5828       gdk_event_free (new_event);
5829       gtk_widget_hide (tree_view->priv->search_window);
5830
5831       g_signal_handler_disconnect (tree_view->priv->search_entry,
5832                                    popup_menu_id);
5833
5834       /* We check to make sure that the entry tried to handle the text, and that
5835        * the text has changed.
5836        */
5837       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5838       text_modified = strcmp (old_text, new_text) != 0;
5839       g_free (old_text);
5840       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5841           (retval && text_modified))               /* ...or the text was modified */
5842         {
5843           if (gtk_tree_view_real_start_interactive_search (tree_view,
5844                                                            gdk_event_get_device ((GdkEvent *) event),
5845                                                            FALSE))
5846             {
5847               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5848               return TRUE;
5849             }
5850           else
5851             {
5852               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5853               return FALSE;
5854             }
5855         }
5856     }
5857
5858   return FALSE;
5859 }
5860
5861 static gboolean
5862 gtk_tree_view_key_release (GtkWidget   *widget,
5863                            GdkEventKey *event)
5864 {
5865   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5866
5867   if (tree_view->priv->rubber_band_status)
5868     return TRUE;
5869
5870   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5871 }
5872
5873 /* FIXME Is this function necessary? Can I get an enter_notify event
5874  * w/o either an expose event or a mouse motion event?
5875  */
5876 static gboolean
5877 gtk_tree_view_enter_notify (GtkWidget        *widget,
5878                             GdkEventCrossing *event)
5879 {
5880   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5881   GtkRBTree *tree;
5882   GtkRBNode *node;
5883   gint new_y;
5884
5885   /* Sanity check it */
5886   if (event->window != tree_view->priv->bin_window)
5887     return FALSE;
5888
5889   if (tree_view->priv->tree == NULL)
5890     return FALSE;
5891
5892   if (event->mode == GDK_CROSSING_GRAB ||
5893       event->mode == GDK_CROSSING_GTK_GRAB ||
5894       event->mode == GDK_CROSSING_GTK_UNGRAB ||
5895       event->mode == GDK_CROSSING_STATE_CHANGED)
5896     return TRUE;
5897
5898   /* find the node internally */
5899   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5900   if (new_y < 0)
5901     new_y = 0;
5902   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5903
5904   tree_view->priv->event_last_x = event->x;
5905   tree_view->priv->event_last_y = event->y;
5906
5907   if ((tree_view->priv->button_pressed_node == NULL) ||
5908       (tree_view->priv->button_pressed_node == node))
5909     prelight_or_select (tree_view, tree, node, event->x, event->y);
5910
5911   return TRUE;
5912 }
5913
5914 static gboolean
5915 gtk_tree_view_leave_notify (GtkWidget        *widget,
5916                             GdkEventCrossing *event)
5917 {
5918   GtkTreeView *tree_view;
5919
5920   if (event->mode == GDK_CROSSING_GRAB ||
5921       event->mode == GDK_CROSSING_GTK_GRAB ||
5922       event->mode == GDK_CROSSING_GTK_UNGRAB)
5923     return TRUE;
5924
5925   tree_view = GTK_TREE_VIEW (widget);
5926
5927   if (tree_view->priv->prelight_node)
5928     _gtk_tree_view_queue_draw_node (tree_view,
5929                                    tree_view->priv->prelight_tree,
5930                                    tree_view->priv->prelight_node,
5931                                    NULL);
5932
5933   tree_view->priv->event_last_x = -10000;
5934   tree_view->priv->event_last_y = -10000;
5935
5936   prelight_or_select (tree_view,
5937                       NULL, NULL,
5938                       -1000, -1000); /* coords not possibly over an arrow */
5939
5940   return TRUE;
5941 }
5942
5943
5944 static gint
5945 gtk_tree_view_focus_out (GtkWidget     *widget,
5946                          GdkEventFocus *event)
5947 {
5948   GtkTreeView *tree_view;
5949
5950   tree_view = GTK_TREE_VIEW (widget);
5951
5952   gtk_widget_queue_draw (widget);
5953
5954   /* destroy interactive search dialog */
5955   if (tree_view->priv->search_window)
5956     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
5957                                       gdk_event_get_device ((GdkEvent *) event));
5958
5959   return FALSE;
5960 }
5961
5962
5963 /* Incremental Reflow
5964  */
5965
5966 static void
5967 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
5968                                  GtkRBTree   *tree,
5969                                  GtkRBNode   *node)
5970 {
5971   GtkAllocation allocation;
5972   gint y;
5973
5974   y = _gtk_rbtree_node_find_offset (tree, node)
5975     - gtk_adjustment_get_value (tree_view->priv->vadjustment)
5976     + gtk_tree_view_get_effective_header_height (tree_view);
5977
5978   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
5979   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
5980                               0, y,
5981                               allocation.width,
5982                               GTK_RBNODE_GET_HEIGHT (node));
5983 }
5984
5985 static gboolean
5986 node_is_visible (GtkTreeView *tree_view,
5987                  GtkRBTree   *tree,
5988                  GtkRBNode   *node)
5989 {
5990   int y;
5991   int height;
5992
5993   y = _gtk_rbtree_node_find_offset (tree, node);
5994   height = gtk_tree_view_get_row_height (tree_view, node);
5995
5996   if (y >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
5997       y + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
5998                      + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
5999     return TRUE;
6000
6001   return FALSE;
6002 }
6003
6004 /* Returns TRUE if it updated the size
6005  */
6006 static gboolean
6007 validate_row (GtkTreeView *tree_view,
6008               GtkRBTree   *tree,
6009               GtkRBNode   *node,
6010               GtkTreeIter *iter,
6011               GtkTreePath *path)
6012 {
6013   GtkTreeViewColumn *column;
6014   GList *list, *first_column, *last_column;
6015   gint height = 0;
6016   gint horizontal_separator;
6017   gint vertical_separator;
6018   gint depth = gtk_tree_path_get_depth (path);
6019   gboolean retval = FALSE;
6020   gboolean is_separator = FALSE;
6021   gboolean draw_vgrid_lines, draw_hgrid_lines;
6022   gint focus_pad;
6023   gint grid_line_width;
6024   gboolean wide_separators;
6025   gint separator_height;
6026
6027   /* double check the row needs validating */
6028   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
6029       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6030     return FALSE;
6031
6032   is_separator = row_is_separator (tree_view, iter, NULL);
6033
6034   gtk_widget_style_get (GTK_WIDGET (tree_view),
6035                         "focus-padding", &focus_pad,
6036                         "horizontal-separator", &horizontal_separator,
6037                         "vertical-separator", &vertical_separator,
6038                         "grid-line-width", &grid_line_width,
6039                         "wide-separators",  &wide_separators,
6040                         "separator-height", &separator_height,
6041                         NULL);
6042
6043   draw_vgrid_lines =
6044     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
6045     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6046   draw_hgrid_lines =
6047     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
6048     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6049
6050   for (last_column = g_list_last (tree_view->priv->columns);
6051        last_column &&
6052        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
6053        last_column = last_column->prev)
6054     ;
6055
6056   for (first_column = g_list_first (tree_view->priv->columns);
6057        first_column &&
6058        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
6059        first_column = first_column->next)
6060     ;
6061
6062   for (list = tree_view->priv->columns; list; list = list->next)
6063     {
6064       gint padding = 0;
6065       gint original_width;
6066       gint new_width;
6067       gint row_height;
6068
6069       column = list->data;
6070
6071       if (!gtk_tree_view_column_get_visible (column))
6072         continue;
6073
6074       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) &&
6075           !_gtk_tree_view_column_cell_get_dirty (column))
6076         continue;
6077
6078       original_width = _gtk_tree_view_column_get_requested_width (column);
6079
6080       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
6081                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
6082                                                node->children?TRUE:FALSE);
6083       gtk_tree_view_column_cell_get_size (column,
6084                                           NULL, NULL, NULL,
6085                                           NULL, &row_height);
6086
6087       if (!is_separator)
6088         {
6089           row_height += vertical_separator;
6090           height = MAX (height, row_height);
6091           height = MAX (height, tree_view->priv->expander_size);
6092         }
6093       else
6094         {
6095           if (wide_separators)
6096             height = separator_height + 2 * focus_pad;
6097           else
6098             height = 2 + 2 * focus_pad;
6099         }
6100
6101       if (gtk_tree_view_is_expander_column (tree_view, column))
6102         {
6103           padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
6104
6105           if (gtk_tree_view_draw_expanders (tree_view))
6106             padding += depth * tree_view->priv->expander_size;
6107         }
6108       else
6109         padding += horizontal_separator;
6110
6111       if (draw_vgrid_lines)
6112         {
6113           if (list->data == first_column || list->data == last_column)
6114             padding += grid_line_width / 2.0;
6115           else
6116             padding += grid_line_width;
6117         }
6118
6119       /* Update the padding for the column */
6120       _gtk_tree_view_column_push_padding (column, padding);
6121       new_width = _gtk_tree_view_column_get_requested_width (column);
6122
6123       if (new_width > original_width)
6124         retval = TRUE;
6125     }
6126
6127   if (draw_hgrid_lines)
6128     height += grid_line_width;
6129
6130   if (height != GTK_RBNODE_GET_HEIGHT (node))
6131     {
6132       retval = TRUE;
6133       _gtk_rbtree_node_set_height (tree, node, height);
6134     }
6135   _gtk_rbtree_node_mark_valid (tree, node);
6136   tree_view->priv->post_validation_flag = TRUE;
6137
6138   return retval;
6139 }
6140
6141
6142 static void
6143 validate_visible_area (GtkTreeView *tree_view)
6144 {
6145   GtkAllocation allocation;
6146   GtkTreePath *path = NULL;
6147   GtkTreePath *above_path = NULL;
6148   GtkTreeIter iter;
6149   GtkRBTree *tree = NULL;
6150   GtkRBNode *node = NULL;
6151   gboolean need_redraw = FALSE;
6152   gboolean size_changed = FALSE;
6153   gint total_height;
6154   gint area_above = 0;
6155   gint area_below = 0;
6156
6157   if (tree_view->priv->tree == NULL)
6158     return;
6159
6160   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
6161       tree_view->priv->scroll_to_path == NULL)
6162     return;
6163
6164   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
6165   total_height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
6166
6167   if (total_height == 0)
6168     return;
6169
6170   /* First, we check to see if we need to scroll anywhere
6171    */
6172   if (tree_view->priv->scroll_to_path)
6173     {
6174       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
6175       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
6176         {
6177           /* we are going to scroll, and will update dy */
6178           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6179           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6180               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6181             {
6182               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6183               if (validate_row (tree_view, tree, node, &iter, path))
6184                 size_changed = TRUE;
6185             }
6186
6187           if (tree_view->priv->scroll_to_use_align)
6188             {
6189               gint height = gtk_tree_view_get_row_height (tree_view, node);
6190               area_above = (total_height - height) *
6191                 tree_view->priv->scroll_to_row_align;
6192               area_below = total_height - area_above - height;
6193               area_above = MAX (area_above, 0);
6194               area_below = MAX (area_below, 0);
6195             }
6196           else
6197             {
6198               /* two cases:
6199                * 1) row not visible
6200                * 2) row visible
6201                */
6202               gint dy;
6203               gint height = gtk_tree_view_get_row_height (tree_view, node);
6204
6205               dy = _gtk_rbtree_node_find_offset (tree, node);
6206
6207               if (dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6208                   dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6209                                   + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6210                 {
6211                   /* row visible: keep the row at the same position */
6212                   area_above = dy - gtk_adjustment_get_value (tree_view->priv->vadjustment);
6213                   area_below = (gtk_adjustment_get_value (tree_view->priv->vadjustment) +
6214                                 gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6215                                - dy - height;
6216                 }
6217               else
6218                 {
6219                   /* row not visible */
6220                   if (dy >= 0
6221                       && dy + height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6222                     {
6223                       /* row at the beginning -- fixed */
6224                       area_above = dy;
6225                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment)
6226                                    - area_above - height;
6227                     }
6228                   else if (dy >= (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6229                                   gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6230                     {
6231                       /* row at the end -- fixed */
6232                       area_above = dy - (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6233                                    gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6234                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) -
6235                                    area_above - height;
6236
6237                       if (area_below < 0)
6238                         {
6239                           area_above = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - height;
6240                           area_below = 0;
6241                         }
6242                     }
6243                   else
6244                     {
6245                       /* row somewhere in the middle, bring it to the top
6246                        * of the view
6247                        */
6248                       area_above = 0;
6249                       area_below = total_height - height;
6250                     }
6251                 }
6252             }
6253         }
6254       else
6255         /* the scroll to isn't valid; ignore it.
6256          */
6257         {
6258           if (tree_view->priv->scroll_to_path && !path)
6259             {
6260               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6261               tree_view->priv->scroll_to_path = NULL;
6262             }
6263           if (path)
6264             gtk_tree_path_free (path);
6265           path = NULL;
6266         }
6267     }
6268
6269   /* We didn't have a scroll_to set, so we just handle things normally
6270    */
6271   if (path == NULL)
6272     {
6273       gint offset;
6274
6275       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6276                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
6277                                         &tree, &node);
6278       if (node == NULL)
6279         {
6280           /* In this case, nothing has been validated */
6281           path = gtk_tree_path_new_first ();
6282           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6283         }
6284       else
6285         {
6286           path = _gtk_tree_path_new_from_rbtree (tree, node);
6287           total_height += offset;
6288         }
6289
6290       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6291
6292       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6293           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6294         {
6295           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6296           if (validate_row (tree_view, tree, node, &iter, path))
6297             size_changed = TRUE;
6298         }
6299       area_above = 0;
6300       area_below = total_height - gtk_tree_view_get_row_height (tree_view, node);
6301     }
6302
6303   above_path = gtk_tree_path_copy (path);
6304
6305   /* if we do not validate any row above the new top_row, we will make sure
6306    * that the row immediately above top_row has been validated. (if we do not
6307    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
6308    * when invalidated that row's height will be zero. and this will mess up
6309    * scrolling).
6310    */
6311   if (area_above == 0)
6312     {
6313       GtkRBTree *tmptree;
6314       GtkRBNode *tmpnode;
6315
6316       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
6317       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
6318
6319       if (tmpnode)
6320         {
6321           GtkTreePath *tmppath;
6322           GtkTreeIter tmpiter;
6323
6324           tmppath = _gtk_tree_path_new_from_rbtree (tmptree, tmpnode);
6325           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
6326
6327           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
6328               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
6329             {
6330               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
6331               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
6332                 size_changed = TRUE;
6333             }
6334
6335           gtk_tree_path_free (tmppath);
6336         }
6337     }
6338
6339   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
6340    * backwards is much slower then forward, as there is no iter_prev function.
6341    * We go forwards first in case we run out of tree.  Then we go backwards to
6342    * fill out the top.
6343    */
6344   while (node && area_below > 0)
6345     {
6346       if (node->children)
6347         {
6348           GtkTreeIter parent = iter;
6349           gboolean has_child;
6350
6351           tree = node->children;
6352           node = _gtk_rbtree_first (tree);
6353
6354           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
6355                                                     &iter,
6356                                                     &parent);
6357           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
6358           gtk_tree_path_down (path);
6359         }
6360       else
6361         {
6362           gboolean done = FALSE;
6363           do
6364             {
6365               node = _gtk_rbtree_next (tree, node);
6366               if (node != NULL)
6367                 {
6368                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
6369                   done = TRUE;
6370                   gtk_tree_path_next (path);
6371
6372                   /* Sanity Check! */
6373                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
6374                 }
6375               else
6376                 {
6377                   GtkTreeIter parent_iter = iter;
6378                   gboolean has_parent;
6379
6380                   node = tree->parent_node;
6381                   tree = tree->parent_tree;
6382                   if (tree == NULL)
6383                     break;
6384                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
6385                                                            &iter,
6386                                                            &parent_iter);
6387                   gtk_tree_path_up (path);
6388
6389                   /* Sanity check */
6390                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
6391                 }
6392             }
6393           while (!done);
6394         }
6395
6396       if (!node)
6397         break;
6398
6399       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6400           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6401         {
6402           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6403           if (validate_row (tree_view, tree, node, &iter, path))
6404               size_changed = TRUE;
6405         }
6406
6407       area_below -= gtk_tree_view_get_row_height (tree_view, node);
6408     }
6409   gtk_tree_path_free (path);
6410
6411   /* If we ran out of tree, and have extra area_below left, we need to add it
6412    * to area_above */
6413   if (area_below > 0)
6414     area_above += area_below;
6415
6416   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
6417
6418   /* We walk backwards */
6419   while (area_above > 0)
6420     {
6421       _gtk_rbtree_prev_full (tree, node, &tree, &node);
6422
6423       /* Always find the new path in the tree.  We cannot just assume
6424        * a gtk_tree_path_prev() is enough here, as there might be children
6425        * in between this node and the previous sibling node.  If this
6426        * appears to be a performance hotspot in profiles, we can look into
6427        * intrigate logic for keeping path, node and iter in sync like
6428        * we do for forward walks.  (Which will be hard because of the lacking
6429        * iter_prev).
6430        */
6431
6432       if (node == NULL)
6433         break;
6434
6435       gtk_tree_path_free (above_path);
6436       above_path = _gtk_tree_path_new_from_rbtree (tree, node);
6437
6438       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
6439
6440       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6441           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6442         {
6443           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6444           if (validate_row (tree_view, tree, node, &iter, above_path))
6445             size_changed = TRUE;
6446         }
6447       area_above -= gtk_tree_view_get_row_height (tree_view, node);
6448     }
6449
6450   /* if we scrolled to a path, we need to set the dy here,
6451    * and sync the top row accordingly
6452    */
6453   if (tree_view->priv->scroll_to_path)
6454     {
6455       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6456       gtk_tree_view_top_row_to_dy (tree_view);
6457
6458       need_redraw = TRUE;
6459     }
6460   else if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6461     {
6462       /* when we are not scrolling, we should never set dy to something
6463        * else than zero. we update top_row to be in sync with dy = 0.
6464        */
6465       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6466       gtk_tree_view_dy_to_top_row (tree_view);
6467     }
6468   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6469     {
6470       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6471       gtk_tree_view_dy_to_top_row (tree_view);
6472     }
6473   else
6474     gtk_tree_view_top_row_to_dy (tree_view);
6475
6476   /* update width/height and queue a resize */
6477   if (size_changed)
6478     {
6479       GtkRequisition requisition;
6480
6481       /* We temporarily guess a size, under the assumption that it will be the
6482        * same when we get our next size_allocate.  If we don't do this, we'll be
6483        * in an inconsistent state if we call top_row_to_dy. */
6484
6485       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6486                                      &requisition, NULL);
6487       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6488                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6489       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6490                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6491       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6492     }
6493
6494   if (tree_view->priv->scroll_to_path)
6495     {
6496       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6497       tree_view->priv->scroll_to_path = NULL;
6498     }
6499
6500   if (above_path)
6501     gtk_tree_path_free (above_path);
6502
6503   if (tree_view->priv->scroll_to_column)
6504     {
6505       tree_view->priv->scroll_to_column = NULL;
6506     }
6507   if (need_redraw)
6508     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6509 }
6510
6511 static void
6512 initialize_fixed_height_mode (GtkTreeView *tree_view)
6513 {
6514   if (!tree_view->priv->tree)
6515     return;
6516
6517   if (tree_view->priv->fixed_height < 0)
6518     {
6519       GtkTreeIter iter;
6520       GtkTreePath *path;
6521
6522       GtkRBTree *tree = NULL;
6523       GtkRBNode *node = NULL;
6524
6525       tree = tree_view->priv->tree;
6526       node = tree->root;
6527
6528       path = _gtk_tree_path_new_from_rbtree (tree, node);
6529       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6530
6531       validate_row (tree_view, tree, node, &iter, path);
6532
6533       gtk_tree_path_free (path);
6534
6535       tree_view->priv->fixed_height = gtk_tree_view_get_row_height (tree_view, node);
6536     }
6537
6538    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6539                                  tree_view->priv->fixed_height, TRUE);
6540 }
6541
6542 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6543  * the left-most uninvalidated node.  We then try walking right, validating
6544  * nodes.  Once we find a valid node, we repeat the previous process of finding
6545  * the first invalid node.
6546  */
6547
6548 static gboolean
6549 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6550 {
6551   GtkRBTree *tree = NULL;
6552   GtkRBNode *node = NULL;
6553   gboolean validated_area = FALSE;
6554   gint retval = TRUE;
6555   GtkTreePath *path = NULL;
6556   GtkTreeIter iter;
6557   GTimer *timer;
6558   gint i = 0;
6559
6560   gint y = -1;
6561   gint prev_height = -1;
6562   gboolean fixed_height = TRUE;
6563
6564   g_assert (tree_view);
6565
6566   if (tree_view->priv->tree == NULL)
6567       return FALSE;
6568
6569   if (tree_view->priv->fixed_height_mode)
6570     {
6571       if (tree_view->priv->fixed_height < 0)
6572         initialize_fixed_height_mode (tree_view);
6573
6574       return FALSE;
6575     }
6576
6577   timer = g_timer_new ();
6578   g_timer_start (timer);
6579
6580   do
6581     {
6582       gboolean changed = FALSE;
6583
6584       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6585         {
6586           retval = FALSE;
6587           goto done;
6588         }
6589
6590       if (path != NULL)
6591         {
6592           node = _gtk_rbtree_next (tree, node);
6593           if (node != NULL)
6594             {
6595               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6596               gtk_tree_path_next (path);
6597             }
6598           else
6599             {
6600               gtk_tree_path_free (path);
6601               path = NULL;
6602             }
6603         }
6604
6605       if (path == NULL)
6606         {
6607           tree = tree_view->priv->tree;
6608           node = tree_view->priv->tree->root;
6609
6610           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6611
6612           do
6613             {
6614               if (!_gtk_rbtree_is_nil (node->left) &&
6615                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6616                 {
6617                   node = node->left;
6618                 }
6619               else if (!_gtk_rbtree_is_nil (node->right) &&
6620                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6621                 {
6622                   node = node->right;
6623                 }
6624               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6625                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6626                 {
6627                   break;
6628                 }
6629               else if (node->children != NULL)
6630                 {
6631                   tree = node->children;
6632                   node = tree->root;
6633                 }
6634               else
6635                 /* RBTree corruption!  All bad */
6636                 g_assert_not_reached ();
6637             }
6638           while (TRUE);
6639           path = _gtk_tree_path_new_from_rbtree (tree, node);
6640           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6641         }
6642
6643       changed = validate_row (tree_view, tree, node, &iter, path);
6644       validated_area = changed || validated_area;
6645
6646       if (changed)
6647         {
6648           gint offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
6649
6650           if (y == -1 || y > offset)
6651             y = offset;
6652         }
6653
6654       if (!tree_view->priv->fixed_height_check)
6655         {
6656           gint height;
6657
6658           height = gtk_tree_view_get_row_height (tree_view, node);
6659           if (prev_height < 0)
6660             prev_height = height;
6661           else if (prev_height != height)
6662             fixed_height = FALSE;
6663         }
6664
6665       i++;
6666     }
6667   while (g_timer_elapsed (timer, NULL) < GTK_TREE_VIEW_TIME_MS_PER_IDLE / 1000.);
6668
6669   if (!tree_view->priv->fixed_height_check)
6670    {
6671      if (fixed_height)
6672        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6673
6674      tree_view->priv->fixed_height_check = 1;
6675    }
6676
6677  done:
6678   if (validated_area)
6679     {
6680       GtkRequisition requisition;
6681
6682       /* We temporarily guess a size, under the assumption that it will be the
6683        * same when we get our next size_allocate.  If we don't do this, we'll be
6684        * in an inconsistent state when we call top_row_to_dy. */
6685
6686       /* FIXME: This is called from size_request, for some reason it is not infinitely
6687        * recursing, we cannot call gtk_widget_get_preferred_size() here because that's
6688        * not allowed (from inside ->get_preferred_width/height() implementations, one
6689        * should call the vfuncs directly). However what is desired here is the full
6690        * size including any margins and limited by any alignment (i.e. after
6691        * GtkWidget:adjust_size_request() is called).
6692        *
6693        * Currently bypassing this but the real solution is to not update the scroll adjustments
6694        * untill we've recieved an allocation (never update scroll adjustments from size-requests).
6695        */
6696       gtk_tree_view_size_request (GTK_WIDGET (tree_view), &requisition, FALSE);
6697
6698       /* If rows above the current position have changed height, this has
6699        * affected the current view and thus needs a redraw.
6700        */
6701       if (y != -1 && y < gtk_adjustment_get_value (tree_view->priv->vadjustment))
6702         gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6703
6704       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6705                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6706       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6707                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6708
6709       if (queue_resize)
6710         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
6711     }
6712
6713   if (path) gtk_tree_path_free (path);
6714   g_timer_destroy (timer);
6715
6716   return retval;
6717 }
6718
6719 static gboolean
6720 validate_rows (GtkTreeView *tree_view)
6721 {
6722   gboolean retval;
6723
6724   retval = do_validate_rows (tree_view, TRUE);
6725
6726   if (! retval && tree_view->priv->validate_rows_timer)
6727     {
6728       g_source_remove (tree_view->priv->validate_rows_timer);
6729       tree_view->priv->validate_rows_timer = 0;
6730     }
6731
6732   return retval;
6733 }
6734
6735 static gboolean
6736 validate_rows_handler (GtkTreeView *tree_view)
6737 {
6738   gboolean retval;
6739
6740   retval = do_validate_rows (tree_view, TRUE);
6741   if (! retval && tree_view->priv->validate_rows_timer)
6742     {
6743       g_source_remove (tree_view->priv->validate_rows_timer);
6744       tree_view->priv->validate_rows_timer = 0;
6745     }
6746
6747   return retval;
6748 }
6749
6750 static gboolean
6751 do_presize_handler (GtkTreeView *tree_view)
6752 {
6753   if (tree_view->priv->mark_rows_col_dirty)
6754     {
6755       if (tree_view->priv->tree)
6756         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6757       tree_view->priv->mark_rows_col_dirty = FALSE;
6758     }
6759   validate_visible_area (tree_view);
6760   tree_view->priv->presize_handler_timer = 0;
6761
6762   if (tree_view->priv->fixed_height_mode)
6763     {
6764       GtkRequisition requisition;
6765
6766       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6767                                      &requisition, NULL);
6768
6769       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6770                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6771       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6772                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6773       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6774     }
6775
6776   return FALSE;
6777 }
6778
6779 static gboolean
6780 presize_handler_callback (gpointer data)
6781 {
6782   do_presize_handler (GTK_TREE_VIEW (data));
6783
6784   return FALSE;
6785 }
6786
6787 static void
6788 install_presize_handler (GtkTreeView *tree_view)
6789 {
6790   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6791     return;
6792
6793   if (! tree_view->priv->presize_handler_timer)
6794     {
6795       tree_view->priv->presize_handler_timer =
6796         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6797     }
6798   if (! tree_view->priv->validate_rows_timer)
6799     {
6800       tree_view->priv->validate_rows_timer =
6801         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6802     }
6803 }
6804
6805 static void
6806 gtk_tree_view_bin_process_updates (GtkTreeView *tree_view)
6807 {
6808   /* Prior to drawing, we make sure the visible area is validated. */
6809   if (tree_view->priv->presize_handler_timer)
6810     {
6811       g_source_remove (tree_view->priv->presize_handler_timer);
6812       tree_view->priv->presize_handler_timer = 0;
6813
6814       do_presize_handler (tree_view);
6815     }
6816
6817   gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
6818 }
6819
6820 static gboolean
6821 scroll_sync_handler (GtkTreeView *tree_view)
6822 {
6823   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6824     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6825   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6826     gtk_tree_view_top_row_to_dy (tree_view);
6827   else
6828     gtk_tree_view_dy_to_top_row (tree_view);
6829
6830   tree_view->priv->scroll_sync_timer = 0;
6831
6832   return FALSE;
6833 }
6834
6835 static void
6836 install_scroll_sync_handler (GtkTreeView *tree_view)
6837 {
6838   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6839     return;
6840
6841   if (!tree_view->priv->scroll_sync_timer)
6842     {
6843       tree_view->priv->scroll_sync_timer =
6844         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6845     }
6846 }
6847
6848 static void
6849 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6850                            GtkTreePath *path,
6851                            gint         offset)
6852 {
6853   gtk_tree_row_reference_free (tree_view->priv->top_row);
6854
6855   if (!path)
6856     {
6857       tree_view->priv->top_row = NULL;
6858       tree_view->priv->top_row_dy = 0;
6859     }
6860   else
6861     {
6862       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6863       tree_view->priv->top_row_dy = offset;
6864     }
6865 }
6866
6867 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6868  * it's set to be NULL, and top_row_dy is 0;
6869  */
6870 static void
6871 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6872 {
6873   gint offset;
6874   GtkTreePath *path;
6875   GtkRBTree *tree;
6876   GtkRBNode *node;
6877
6878   if (tree_view->priv->tree == NULL)
6879     {
6880       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6881     }
6882   else
6883     {
6884       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6885                                         tree_view->priv->dy,
6886                                         &tree, &node);
6887
6888       if (tree == NULL)
6889         {
6890           gtk_tree_view_set_top_row (tree_view, NULL, 0);
6891         }
6892       else
6893         {
6894           path = _gtk_tree_path_new_from_rbtree (tree, node);
6895           gtk_tree_view_set_top_row (tree_view, path, offset);
6896           gtk_tree_path_free (path);
6897         }
6898     }
6899 }
6900
6901 static void
6902 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6903 {
6904   GtkTreePath *path;
6905   GtkRBTree *tree;
6906   GtkRBNode *node;
6907   int new_dy;
6908
6909   /* Avoid recursive calls */
6910   if (tree_view->priv->in_top_row_to_dy)
6911     return;
6912
6913   if (tree_view->priv->top_row)
6914     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6915   else
6916     path = NULL;
6917
6918   if (!path)
6919     tree = NULL;
6920   else
6921     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6922
6923   if (path)
6924     gtk_tree_path_free (path);
6925
6926   if (tree == NULL)
6927     {
6928       /* keep dy and set new toprow */
6929       gtk_tree_row_reference_free (tree_view->priv->top_row);
6930       tree_view->priv->top_row = NULL;
6931       tree_view->priv->top_row_dy = 0;
6932       /* DO NOT install the idle handler */
6933       gtk_tree_view_dy_to_top_row (tree_view);
6934       return;
6935     }
6936
6937   if (gtk_tree_view_get_row_height (tree_view, node)
6938       < tree_view->priv->top_row_dy)
6939     {
6940       /* new top row -- do NOT install the idle handler */
6941       gtk_tree_view_dy_to_top_row (tree_view);
6942       return;
6943     }
6944
6945   new_dy = _gtk_rbtree_node_find_offset (tree, node);
6946   new_dy += tree_view->priv->top_row_dy;
6947
6948   if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6949     new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
6950
6951   new_dy = MAX (0, new_dy);
6952
6953   tree_view->priv->in_top_row_to_dy = TRUE;
6954   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
6955   tree_view->priv->in_top_row_to_dy = FALSE;
6956 }
6957
6958
6959 void
6960 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view,
6961                                             gboolean     install_handler)
6962 {
6963   tree_view->priv->mark_rows_col_dirty = TRUE;
6964
6965   if (install_handler)
6966     install_presize_handler (tree_view);
6967 }
6968
6969 /*
6970  * This function works synchronously (due to the while (validate_rows...)
6971  * loop).
6972  *
6973  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
6974  * here. You now need to check that yourself.
6975  */
6976 void
6977 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
6978                                 GtkTreeViewColumn *column)
6979 {
6980   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6981   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
6982
6983   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
6984
6985   do_presize_handler (tree_view);
6986   while (validate_rows (tree_view));
6987
6988   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6989 }
6990
6991 /* Drag-and-drop */
6992
6993 static void
6994 set_source_row (GdkDragContext *context,
6995                 GtkTreeModel   *model,
6996                 GtkTreePath    *source_row)
6997 {
6998   g_object_set_data_full (G_OBJECT (context),
6999                           I_("gtk-tree-view-source-row"),
7000                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
7001                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
7002 }
7003
7004 static GtkTreePath*
7005 get_source_row (GdkDragContext *context)
7006 {
7007   GtkTreeRowReference *ref =
7008     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
7009
7010   if (ref)
7011     return gtk_tree_row_reference_get_path (ref);
7012   else
7013     return NULL;
7014 }
7015
7016 typedef struct
7017 {
7018   GtkTreeRowReference *dest_row;
7019   guint                path_down_mode   : 1;
7020   guint                empty_view_drop  : 1;
7021   guint                drop_append_mode : 1;
7022 }
7023 DestRow;
7024
7025 static void
7026 dest_row_free (gpointer data)
7027 {
7028   DestRow *dr = (DestRow *)data;
7029
7030   gtk_tree_row_reference_free (dr->dest_row);
7031   g_slice_free (DestRow, dr);
7032 }
7033
7034 static void
7035 set_dest_row (GdkDragContext *context,
7036               GtkTreeModel   *model,
7037               GtkTreePath    *dest_row,
7038               gboolean        path_down_mode,
7039               gboolean        empty_view_drop,
7040               gboolean        drop_append_mode)
7041 {
7042   DestRow *dr;
7043
7044   if (!dest_row)
7045     {
7046       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7047                               NULL, NULL);
7048       return;
7049     }
7050
7051   dr = g_slice_new (DestRow);
7052
7053   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
7054   dr->path_down_mode = path_down_mode != FALSE;
7055   dr->empty_view_drop = empty_view_drop != FALSE;
7056   dr->drop_append_mode = drop_append_mode != FALSE;
7057
7058   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7059                           dr, (GDestroyNotify) dest_row_free);
7060 }
7061
7062 static GtkTreePath*
7063 get_dest_row (GdkDragContext *context,
7064               gboolean       *path_down_mode)
7065 {
7066   DestRow *dr =
7067     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
7068
7069   if (dr)
7070     {
7071       GtkTreePath *path = NULL;
7072
7073       if (path_down_mode)
7074         *path_down_mode = dr->path_down_mode;
7075
7076       if (dr->dest_row)
7077         path = gtk_tree_row_reference_get_path (dr->dest_row);
7078       else if (dr->empty_view_drop)
7079         path = gtk_tree_path_new_from_indices (0, -1);
7080       else
7081         path = NULL;
7082
7083       if (path && dr->drop_append_mode)
7084         gtk_tree_path_next (path);
7085
7086       return path;
7087     }
7088   else
7089     return NULL;
7090 }
7091
7092 /* Get/set whether drag_motion requested the drag data and
7093  * drag_data_received should thus not actually insert the data,
7094  * since the data doesn't result from a drop.
7095  */
7096 static void
7097 set_status_pending (GdkDragContext *context,
7098                     GdkDragAction   suggested_action)
7099 {
7100   g_object_set_data (G_OBJECT (context),
7101                      I_("gtk-tree-view-status-pending"),
7102                      GINT_TO_POINTER (suggested_action));
7103 }
7104
7105 static GdkDragAction
7106 get_status_pending (GdkDragContext *context)
7107 {
7108   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
7109                                              "gtk-tree-view-status-pending"));
7110 }
7111
7112 static TreeViewDragInfo*
7113 get_info (GtkTreeView *tree_view)
7114 {
7115   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
7116 }
7117
7118 static void
7119 destroy_info (TreeViewDragInfo *di)
7120 {
7121   g_slice_free (TreeViewDragInfo, di);
7122 }
7123
7124 static TreeViewDragInfo*
7125 ensure_info (GtkTreeView *tree_view)
7126 {
7127   TreeViewDragInfo *di;
7128
7129   di = get_info (tree_view);
7130
7131   if (di == NULL)
7132     {
7133       di = g_slice_new0 (TreeViewDragInfo);
7134
7135       g_object_set_data_full (G_OBJECT (tree_view),
7136                               I_("gtk-tree-view-drag-info"),
7137                               di,
7138                               (GDestroyNotify) destroy_info);
7139     }
7140
7141   return di;
7142 }
7143
7144 static void
7145 remove_info (GtkTreeView *tree_view)
7146 {
7147   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
7148 }
7149
7150 #if 0
7151 static gint
7152 drag_scan_timeout (gpointer data)
7153 {
7154   GtkTreeView *tree_view;
7155   gint x, y;
7156   GdkModifierType state;
7157   GtkTreePath *path = NULL;
7158   GtkTreeViewColumn *column = NULL;
7159   GdkRectangle visible_rect;
7160
7161   GDK_THREADS_ENTER ();
7162
7163   tree_view = GTK_TREE_VIEW (data);
7164
7165   gdk_window_get_device_position (tree_view->priv->bin_window,
7166                                   gdk_device_manager_get_client_pointer (
7167                                     gdk_display_get_device_manager (
7168                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
7169                                   &x, &y, &state);
7170
7171   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
7172
7173   /* See if we are near the edge. */
7174   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
7175       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
7176       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
7177       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
7178     {
7179       gtk_tree_view_get_path_at_pos (tree_view,
7180                                      tree_view->priv->bin_window,
7181                                      x, y,
7182                                      &path,
7183                                      &column,
7184                                      NULL,
7185                                      NULL);
7186
7187       if (path != NULL)
7188         {
7189           gtk_tree_view_scroll_to_cell (tree_view,
7190                                         path,
7191                                         column,
7192                                         TRUE,
7193                                         0.5, 0.5);
7194
7195           gtk_tree_path_free (path);
7196         }
7197     }
7198
7199   GDK_THREADS_LEAVE ();
7200
7201   return TRUE;
7202 }
7203 #endif /* 0 */
7204
7205 static void
7206 add_scroll_timeout (GtkTreeView *tree_view)
7207 {
7208   if (tree_view->priv->scroll_timeout == 0)
7209     {
7210       tree_view->priv->scroll_timeout =
7211         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
7212     }
7213 }
7214
7215 static void
7216 remove_scroll_timeout (GtkTreeView *tree_view)
7217 {
7218   if (tree_view->priv->scroll_timeout != 0)
7219     {
7220       g_source_remove (tree_view->priv->scroll_timeout);
7221       tree_view->priv->scroll_timeout = 0;
7222     }
7223 }
7224
7225 static gboolean
7226 check_model_dnd (GtkTreeModel *model,
7227                  GType         required_iface,
7228                  const gchar  *signal)
7229 {
7230   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
7231     {
7232       g_warning ("You must override the default '%s' handler "
7233                  "on GtkTreeView when using models that don't support "
7234                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
7235                  "is to connect to '%s' and call "
7236                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
7237                  "the default handler from running. Look at the source code "
7238                  "for the default handler in gtktreeview.c to get an idea what "
7239                  "your handler should do. (gtktreeview.c is in the GTK source "
7240                  "code.) If you're using GTK from a language other than C, "
7241                  "there may be a more natural way to override default handlers, e.g. via derivation.",
7242                  signal, g_type_name (required_iface), signal);
7243       return FALSE;
7244     }
7245   else
7246     return TRUE;
7247 }
7248
7249 static void
7250 remove_open_timeout (GtkTreeView *tree_view)
7251 {
7252   if (tree_view->priv->open_dest_timeout != 0)
7253     {
7254       g_source_remove (tree_view->priv->open_dest_timeout);
7255       tree_view->priv->open_dest_timeout = 0;
7256     }
7257 }
7258
7259
7260 static gint
7261 open_row_timeout (gpointer data)
7262 {
7263   GtkTreeView *tree_view = data;
7264   GtkTreePath *dest_path = NULL;
7265   GtkTreeViewDropPosition pos;
7266   gboolean result = FALSE;
7267
7268   gtk_tree_view_get_drag_dest_row (tree_view,
7269                                    &dest_path,
7270                                    &pos);
7271
7272   if (dest_path &&
7273       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7274        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7275     {
7276       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
7277       tree_view->priv->open_dest_timeout = 0;
7278
7279       gtk_tree_path_free (dest_path);
7280     }
7281   else
7282     {
7283       if (dest_path)
7284         gtk_tree_path_free (dest_path);
7285
7286       result = TRUE;
7287     }
7288
7289   return result;
7290 }
7291
7292 static gboolean
7293 scroll_row_timeout (gpointer data)
7294 {
7295   GtkTreeView *tree_view = data;
7296
7297   gtk_tree_view_vertical_autoscroll (tree_view);
7298
7299   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
7300     gtk_tree_view_update_rubber_band (tree_view);
7301
7302   return TRUE;
7303 }
7304
7305 /* Returns TRUE if event should not be propagated to parent widgets */
7306 static gboolean
7307 set_destination_row (GtkTreeView    *tree_view,
7308                      GdkDragContext *context,
7309                      /* coordinates relative to the widget */
7310                      gint            x,
7311                      gint            y,
7312                      GdkDragAction  *suggested_action,
7313                      GdkAtom        *target)
7314 {
7315   GtkTreePath *path = NULL;
7316   GtkTreeViewDropPosition pos;
7317   GtkTreeViewDropPosition old_pos;
7318   TreeViewDragInfo *di;
7319   GtkWidget *widget;
7320   GtkTreePath *old_dest_path = NULL;
7321   gboolean can_drop = FALSE;
7322
7323   *suggested_action = 0;
7324   *target = GDK_NONE;
7325
7326   widget = GTK_WIDGET (tree_view);
7327
7328   di = get_info (tree_view);
7329
7330   if (di == NULL || y - gtk_tree_view_get_effective_header_height (tree_view) < 0)
7331     {
7332       /* someone unset us as a drag dest, note that if
7333        * we return FALSE drag_leave isn't called
7334        */
7335
7336       gtk_tree_view_set_drag_dest_row (tree_view,
7337                                        NULL,
7338                                        GTK_TREE_VIEW_DROP_BEFORE);
7339
7340       remove_scroll_timeout (GTK_TREE_VIEW (widget));
7341       remove_open_timeout (GTK_TREE_VIEW (widget));
7342
7343       return FALSE; /* no longer a drop site */
7344     }
7345
7346   *target = gtk_drag_dest_find_target (widget, context,
7347                                        gtk_drag_dest_get_target_list (widget));
7348   if (*target == GDK_NONE)
7349     {
7350       return FALSE;
7351     }
7352
7353   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
7354                                           x, y,
7355                                           &path,
7356                                           &pos))
7357     {
7358       gint n_children;
7359       GtkTreeModel *model;
7360
7361       remove_open_timeout (tree_view);
7362
7363       /* the row got dropped on empty space, let's setup a special case
7364        */
7365
7366       if (path)
7367         gtk_tree_path_free (path);
7368
7369       model = gtk_tree_view_get_model (tree_view);
7370
7371       n_children = gtk_tree_model_iter_n_children (model, NULL);
7372       if (n_children)
7373         {
7374           pos = GTK_TREE_VIEW_DROP_AFTER;
7375           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
7376         }
7377       else
7378         {
7379           pos = GTK_TREE_VIEW_DROP_BEFORE;
7380           path = gtk_tree_path_new_from_indices (0, -1);
7381         }
7382
7383       can_drop = TRUE;
7384
7385       goto out;
7386     }
7387
7388   g_assert (path);
7389
7390   /* If we left the current row's "open" zone, unset the timeout for
7391    * opening the row
7392    */
7393   gtk_tree_view_get_drag_dest_row (tree_view,
7394                                    &old_dest_path,
7395                                    &old_pos);
7396
7397   if (old_dest_path &&
7398       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
7399        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7400          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
7401     remove_open_timeout (tree_view);
7402
7403   if (old_dest_path)
7404     gtk_tree_path_free (old_dest_path);
7405
7406   if (TRUE /* FIXME if the location droppable predicate */)
7407     {
7408       can_drop = TRUE;
7409     }
7410
7411 out:
7412   if (can_drop)
7413     {
7414       GtkWidget *source_widget;
7415
7416       *suggested_action = gdk_drag_context_get_suggested_action (context);
7417       source_widget = gtk_drag_get_source_widget (context);
7418
7419       if (source_widget == widget)
7420         {
7421           /* Default to MOVE, unless the user has
7422            * pressed ctrl or shift to affect available actions
7423            */
7424           if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
7425             *suggested_action = GDK_ACTION_MOVE;
7426         }
7427
7428       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7429                                        path, pos);
7430     }
7431   else
7432     {
7433       /* can't drop here */
7434       remove_open_timeout (tree_view);
7435
7436       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7437                                        NULL,
7438                                        GTK_TREE_VIEW_DROP_BEFORE);
7439     }
7440
7441   if (path)
7442     gtk_tree_path_free (path);
7443
7444   return TRUE;
7445 }
7446
7447 static GtkTreePath*
7448 get_logical_dest_row (GtkTreeView *tree_view,
7449                       gboolean    *path_down_mode,
7450                       gboolean    *drop_append_mode)
7451 {
7452   /* adjust path to point to the row the drop goes in front of */
7453   GtkTreePath *path = NULL;
7454   GtkTreeViewDropPosition pos;
7455
7456   g_return_val_if_fail (path_down_mode != NULL, NULL);
7457   g_return_val_if_fail (drop_append_mode != NULL, NULL);
7458
7459   *path_down_mode = FALSE;
7460   *drop_append_mode = 0;
7461
7462   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7463
7464   if (path == NULL)
7465     return NULL;
7466
7467   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
7468     ; /* do nothing */
7469   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
7470            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
7471     *path_down_mode = TRUE;
7472   else
7473     {
7474       GtkTreeIter iter;
7475       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
7476
7477       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
7478
7479       if (!gtk_tree_model_get_iter (model, &iter, path) ||
7480           !gtk_tree_model_iter_next (model, &iter))
7481         *drop_append_mode = 1;
7482       else
7483         {
7484           *drop_append_mode = 0;
7485           gtk_tree_path_next (path);
7486         }
7487     }
7488
7489   return path;
7490 }
7491
7492 static gboolean
7493 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
7494                                         GdkEventMotion   *event)
7495 {
7496   GtkWidget *widget = GTK_WIDGET (tree_view);
7497   GdkDragContext *context;
7498   TreeViewDragInfo *di;
7499   GtkTreePath *path = NULL;
7500   gint button;
7501   gint cell_x, cell_y;
7502   GtkTreeModel *model;
7503   gboolean retval = FALSE;
7504
7505   di = get_info (tree_view);
7506
7507   if (di == NULL || !di->source_set)
7508     goto out;
7509
7510   if (tree_view->priv->pressed_button < 0)
7511     goto out;
7512
7513   if (!gtk_drag_check_threshold (widget,
7514                                  tree_view->priv->press_start_x,
7515                                  tree_view->priv->press_start_y,
7516                                  event->x, event->y))
7517     goto out;
7518
7519   model = gtk_tree_view_get_model (tree_view);
7520
7521   if (model == NULL)
7522     goto out;
7523
7524   button = tree_view->priv->pressed_button;
7525   tree_view->priv->pressed_button = -1;
7526
7527   gtk_tree_view_get_path_at_pos (tree_view,
7528                                  tree_view->priv->press_start_x,
7529                                  tree_view->priv->press_start_y,
7530                                  &path,
7531                                  NULL,
7532                                  &cell_x,
7533                                  &cell_y);
7534
7535   if (path == NULL)
7536     goto out;
7537
7538   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7539       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7540                                            path))
7541     goto out;
7542
7543   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7544     goto out;
7545
7546   /* Now we can begin the drag */
7547
7548   retval = TRUE;
7549
7550   context = gtk_drag_begin (widget,
7551                             gtk_drag_source_get_target_list (widget),
7552                             di->source_actions,
7553                             button,
7554                             (GdkEvent*)event);
7555
7556   set_source_row (context, model, path);
7557
7558  out:
7559   if (path)
7560     gtk_tree_path_free (path);
7561
7562   return retval;
7563 }
7564
7565
7566 static void
7567 gtk_tree_view_drag_begin (GtkWidget      *widget,
7568                           GdkDragContext *context)
7569 {
7570   GtkTreeView *tree_view;
7571   GtkTreePath *path = NULL;
7572   gint cell_x, cell_y;
7573   cairo_surface_t *row_pix;
7574   TreeViewDragInfo *di;
7575
7576   tree_view = GTK_TREE_VIEW (widget);
7577
7578   /* if the user uses a custom DND source impl, we don't set the icon here */
7579   di = get_info (tree_view);
7580
7581   if (di == NULL || !di->source_set)
7582     return;
7583
7584   gtk_tree_view_get_path_at_pos (tree_view,
7585                                  tree_view->priv->press_start_x,
7586                                  tree_view->priv->press_start_y,
7587                                  &path,
7588                                  NULL,
7589                                  &cell_x,
7590                                  &cell_y);
7591
7592   /* If path is NULL, there's nothing we can drag.  For now, we silently
7593    * bail out.  Actually, dragging should not be possible from an empty
7594    * tree view, but there's no way we can cancel that from here.
7595    * Automatically unsetting the tree view as drag source for empty models
7596    * is something that would likely break other people's code ...
7597    */
7598   if (!path)
7599     return;
7600
7601   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7602                                                 path);
7603   cairo_surface_set_device_offset (row_pix,
7604                                    /* the + 1 is for the black border in the icon */
7605                                    - (tree_view->priv->press_start_x + 1),
7606                                    - (cell_y + 1));
7607
7608   gtk_drag_set_icon_surface (context, row_pix);
7609
7610   cairo_surface_destroy (row_pix);
7611   gtk_tree_path_free (path);
7612 }
7613
7614 static void
7615 gtk_tree_view_drag_end (GtkWidget      *widget,
7616                         GdkDragContext *context)
7617 {
7618   /* do nothing */
7619 }
7620
7621 /* Default signal implementations for the drag signals */
7622 static void
7623 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7624                              GdkDragContext   *context,
7625                              GtkSelectionData *selection_data,
7626                              guint             info,
7627                              guint             time)
7628 {
7629   GtkTreeView *tree_view;
7630   GtkTreeModel *model;
7631   TreeViewDragInfo *di;
7632   GtkTreePath *source_row;
7633
7634   tree_view = GTK_TREE_VIEW (widget);
7635
7636   model = gtk_tree_view_get_model (tree_view);
7637
7638   if (model == NULL)
7639     return;
7640
7641   di = get_info (GTK_TREE_VIEW (widget));
7642
7643   if (di == NULL)
7644     return;
7645
7646   source_row = get_source_row (context);
7647
7648   if (source_row == NULL)
7649     return;
7650
7651   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7652    * any model; for DragSource models there are some other targets
7653    * we also support.
7654    */
7655
7656   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7657       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7658                                           source_row,
7659                                           selection_data))
7660     goto done;
7661
7662   /* If drag_data_get does nothing, try providing row data. */
7663   if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7664     {
7665       gtk_tree_set_row_drag_data (selection_data,
7666                                   model,
7667                                   source_row);
7668     }
7669
7670  done:
7671   gtk_tree_path_free (source_row);
7672 }
7673
7674
7675 static void
7676 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7677                                 GdkDragContext *context)
7678 {
7679   TreeViewDragInfo *di;
7680   GtkTreeModel *model;
7681   GtkTreeView *tree_view;
7682   GtkTreePath *source_row;
7683
7684   tree_view = GTK_TREE_VIEW (widget);
7685   model = gtk_tree_view_get_model (tree_view);
7686
7687   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7688     return;
7689
7690   di = get_info (tree_view);
7691
7692   if (di == NULL)
7693     return;
7694
7695   source_row = get_source_row (context);
7696
7697   if (source_row == NULL)
7698     return;
7699
7700   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7701                                          source_row);
7702
7703   gtk_tree_path_free (source_row);
7704
7705   set_source_row (context, NULL, NULL);
7706 }
7707
7708 static void
7709 gtk_tree_view_drag_leave (GtkWidget      *widget,
7710                           GdkDragContext *context,
7711                           guint             time)
7712 {
7713   /* unset any highlight row */
7714   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7715                                    NULL,
7716                                    GTK_TREE_VIEW_DROP_BEFORE);
7717
7718   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7719   remove_open_timeout (GTK_TREE_VIEW (widget));
7720 }
7721
7722
7723 static gboolean
7724 gtk_tree_view_drag_motion (GtkWidget        *widget,
7725                            GdkDragContext   *context,
7726                            /* coordinates relative to the widget */
7727                            gint              x,
7728                            gint              y,
7729                            guint             time)
7730 {
7731   gboolean empty;
7732   GtkTreePath *path = NULL;
7733   GtkTreeViewDropPosition pos;
7734   GtkTreeView *tree_view;
7735   GdkDragAction suggested_action = 0;
7736   GdkAtom target;
7737
7738   tree_view = GTK_TREE_VIEW (widget);
7739
7740   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7741     return FALSE;
7742
7743   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7744
7745   /* we only know this *after* set_desination_row */
7746   empty = tree_view->priv->empty_view_drop;
7747
7748   if (path == NULL && !empty)
7749     {
7750       /* Can't drop here. */
7751       gdk_drag_status (context, 0, time);
7752     }
7753   else
7754     {
7755       if (tree_view->priv->open_dest_timeout == 0 &&
7756           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7757            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7758         {
7759           tree_view->priv->open_dest_timeout =
7760             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7761         }
7762       else
7763         {
7764           add_scroll_timeout (tree_view);
7765         }
7766
7767       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7768         {
7769           /* Request data so we can use the source row when
7770            * determining whether to accept the drop
7771            */
7772           set_status_pending (context, suggested_action);
7773           gtk_drag_get_data (widget, context, target, time);
7774         }
7775       else
7776         {
7777           set_status_pending (context, 0);
7778           gdk_drag_status (context, suggested_action, time);
7779         }
7780     }
7781
7782   if (path)
7783     gtk_tree_path_free (path);
7784
7785   return TRUE;
7786 }
7787
7788
7789 static gboolean
7790 gtk_tree_view_drag_drop (GtkWidget        *widget,
7791                          GdkDragContext   *context,
7792                          /* coordinates relative to the widget */
7793                          gint              x,
7794                          gint              y,
7795                          guint             time)
7796 {
7797   GtkTreeView *tree_view;
7798   GtkTreePath *path;
7799   GdkDragAction suggested_action = 0;
7800   GdkAtom target = GDK_NONE;
7801   TreeViewDragInfo *di;
7802   GtkTreeModel *model;
7803   gboolean path_down_mode;
7804   gboolean drop_append_mode;
7805
7806   tree_view = GTK_TREE_VIEW (widget);
7807
7808   model = gtk_tree_view_get_model (tree_view);
7809
7810   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7811   remove_open_timeout (GTK_TREE_VIEW (widget));
7812
7813   di = get_info (tree_view);
7814
7815   if (di == NULL)
7816     return FALSE;
7817
7818   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7819     return FALSE;
7820
7821   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7822     return FALSE;
7823
7824   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7825
7826   if (target != GDK_NONE && path != NULL)
7827     {
7828       /* in case a motion had requested drag data, change things so we
7829        * treat drag data receives as a drop.
7830        */
7831       set_status_pending (context, 0);
7832       set_dest_row (context, model, path,
7833                     path_down_mode, tree_view->priv->empty_view_drop,
7834                     drop_append_mode);
7835     }
7836
7837   if (path)
7838     gtk_tree_path_free (path);
7839
7840   /* Unset this thing */
7841   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7842                                    NULL,
7843                                    GTK_TREE_VIEW_DROP_BEFORE);
7844
7845   if (target != GDK_NONE)
7846     {
7847       gtk_drag_get_data (widget, context, target, time);
7848       return TRUE;
7849     }
7850   else
7851     return FALSE;
7852 }
7853
7854 static void
7855 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7856                                   GdkDragContext   *context,
7857                                   /* coordinates relative to the widget */
7858                                   gint              x,
7859                                   gint              y,
7860                                   GtkSelectionData *selection_data,
7861                                   guint             info,
7862                                   guint             time)
7863 {
7864   GtkTreePath *path;
7865   TreeViewDragInfo *di;
7866   gboolean accepted = FALSE;
7867   GtkTreeModel *model;
7868   GtkTreeView *tree_view;
7869   GtkTreePath *dest_row;
7870   GdkDragAction suggested_action;
7871   gboolean path_down_mode;
7872   gboolean drop_append_mode;
7873
7874   tree_view = GTK_TREE_VIEW (widget);
7875
7876   model = gtk_tree_view_get_model (tree_view);
7877
7878   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7879     return;
7880
7881   di = get_info (tree_view);
7882
7883   if (di == NULL)
7884     return;
7885
7886   suggested_action = get_status_pending (context);
7887
7888   if (suggested_action)
7889     {
7890       /* We are getting this data due to a request in drag_motion,
7891        * rather than due to a request in drag_drop, so we are just
7892        * supposed to call drag_status, not actually paste in the
7893        * data.
7894        */
7895       path = get_logical_dest_row (tree_view, &path_down_mode,
7896                                    &drop_append_mode);
7897
7898       if (path == NULL)
7899         suggested_action = 0;
7900       else if (path_down_mode)
7901         gtk_tree_path_down (path);
7902
7903       if (suggested_action)
7904         {
7905           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7906                                                      path,
7907                                                      selection_data))
7908             {
7909               if (path_down_mode)
7910                 {
7911                   path_down_mode = FALSE;
7912                   gtk_tree_path_up (path);
7913
7914                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7915                                                              path,
7916                                                              selection_data))
7917                     suggested_action = 0;
7918                 }
7919               else
7920                 suggested_action = 0;
7921             }
7922         }
7923
7924       gdk_drag_status (context, suggested_action, time);
7925
7926       if (path)
7927         gtk_tree_path_free (path);
7928
7929       /* If you can't drop, remove user drop indicator until the next motion */
7930       if (suggested_action == 0)
7931         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7932                                          NULL,
7933                                          GTK_TREE_VIEW_DROP_BEFORE);
7934
7935       return;
7936     }
7937
7938   dest_row = get_dest_row (context, &path_down_mode);
7939
7940   if (dest_row == NULL)
7941     return;
7942
7943   if (gtk_selection_data_get_length (selection_data) >= 0)
7944     {
7945       if (path_down_mode)
7946         {
7947           gtk_tree_path_down (dest_row);
7948           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7949                                                      dest_row, selection_data))
7950             gtk_tree_path_up (dest_row);
7951         }
7952     }
7953
7954   if (gtk_selection_data_get_length (selection_data) >= 0)
7955     {
7956       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
7957                                                  dest_row,
7958                                                  selection_data))
7959         accepted = TRUE;
7960     }
7961
7962   gtk_drag_finish (context,
7963                    accepted,
7964                    (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
7965                    time);
7966
7967   if (gtk_tree_path_get_depth (dest_row) == 1 &&
7968       gtk_tree_path_get_indices (dest_row)[0] == 0 &&
7969       gtk_tree_model_iter_n_children (tree_view->priv->model, NULL) != 0)
7970     {
7971       /* special special case drag to "0", scroll to first item */
7972       if (!tree_view->priv->scroll_to_path)
7973         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
7974     }
7975
7976   gtk_tree_path_free (dest_row);
7977
7978   /* drop dest_row */
7979   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
7980 }
7981
7982
7983
7984 /* GtkContainer Methods
7985  */
7986
7987
7988 static void
7989 gtk_tree_view_remove (GtkContainer *container,
7990                       GtkWidget    *widget)
7991 {
7992   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7993   GtkTreeViewChild *child = NULL;
7994   GList *tmp_list;
7995
7996   tmp_list = tree_view->priv->children;
7997   while (tmp_list)
7998     {
7999       child = tmp_list->data;
8000       if (child->widget == widget)
8001         {
8002           gtk_widget_unparent (widget);
8003
8004           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
8005           g_list_free_1 (tmp_list);
8006           g_slice_free (GtkTreeViewChild, child);
8007           return;
8008         }
8009
8010       tmp_list = tmp_list->next;
8011     }
8012
8013   tmp_list = tree_view->priv->columns;
8014
8015   while (tmp_list)
8016     {
8017       GtkTreeViewColumn *column;
8018       GtkWidget         *button;
8019
8020       column = tmp_list->data;
8021       button = gtk_tree_view_column_get_button (column);
8022
8023       if (button == widget)
8024         {
8025           gtk_widget_unparent (widget);
8026           return;
8027         }
8028       tmp_list = tmp_list->next;
8029     }
8030 }
8031
8032 static void
8033 gtk_tree_view_forall (GtkContainer *container,
8034                       gboolean      include_internals,
8035                       GtkCallback   callback,
8036                       gpointer      callback_data)
8037 {
8038   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8039   GtkTreeViewChild *child = NULL;
8040   GtkTreeViewColumn *column;
8041   GtkWidget *button;
8042   GList *tmp_list;
8043
8044   tmp_list = tree_view->priv->children;
8045   while (tmp_list)
8046     {
8047       child = tmp_list->data;
8048       tmp_list = tmp_list->next;
8049
8050       (* callback) (child->widget, callback_data);
8051     }
8052   if (include_internals == FALSE)
8053     return;
8054
8055   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8056     {
8057       column = tmp_list->data;
8058       button = gtk_tree_view_column_get_button (column);
8059
8060       if (button)
8061         (* callback) (button, callback_data);
8062     }
8063 }
8064
8065 /* Returns TRUE is any of the columns contains a cell that can-focus.
8066  * If this is not the case, a column-spanning focus rectangle will be
8067  * drawn.
8068  */
8069 static gboolean
8070 gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view)
8071 {
8072   GList *list;
8073
8074   for (list = tree_view->priv->columns; list; list = list->next)
8075     {
8076       GtkTreeViewColumn *column = list->data;
8077
8078       if (!gtk_tree_view_column_get_visible (column))
8079         continue;
8080       if (gtk_cell_area_is_activatable (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column))))
8081         return TRUE;
8082     }
8083
8084   return FALSE;
8085 }
8086
8087 static void
8088 column_sizing_notify (GObject    *object,
8089                       GParamSpec *pspec,
8090                       gpointer    data)
8091 {
8092   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
8093
8094   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
8095     /* disable fixed height mode */
8096     g_object_set (data, "fixed-height-mode", FALSE, NULL);
8097 }
8098
8099 /**
8100  * gtk_tree_view_set_fixed_height_mode:
8101  * @tree_view: a #GtkTreeView
8102  * @enable: %TRUE to enable fixed height mode
8103  *
8104  * Enables or disables the fixed height mode of @tree_view.
8105  * Fixed height mode speeds up #GtkTreeView by assuming that all
8106  * rows have the same height.
8107  * Only enable this option if all rows are the same height and all
8108  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
8109  *
8110  * Since: 2.6
8111  **/
8112 void
8113 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
8114                                      gboolean     enable)
8115 {
8116   GList *l;
8117
8118   enable = enable != FALSE;
8119
8120   if (enable == tree_view->priv->fixed_height_mode)
8121     return;
8122
8123   if (!enable)
8124     {
8125       tree_view->priv->fixed_height_mode = 0;
8126       tree_view->priv->fixed_height = -1;
8127
8128       /* force a revalidation */
8129       install_presize_handler (tree_view);
8130     }
8131   else
8132     {
8133       /* make sure all columns are of type FIXED */
8134       for (l = tree_view->priv->columns; l; l = l->next)
8135         {
8136           GtkTreeViewColumn *c = l->data;
8137
8138           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
8139         }
8140
8141       /* yes, we really have to do this is in a separate loop */
8142       for (l = tree_view->priv->columns; l; l = l->next)
8143         g_signal_connect (l->data, "notify::sizing",
8144                           G_CALLBACK (column_sizing_notify), tree_view);
8145
8146       tree_view->priv->fixed_height_mode = 1;
8147       tree_view->priv->fixed_height = -1;
8148
8149       if (tree_view->priv->tree)
8150         initialize_fixed_height_mode (tree_view);
8151     }
8152
8153   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
8154 }
8155
8156 /**
8157  * gtk_tree_view_get_fixed_height_mode:
8158  * @tree_view: a #GtkTreeView
8159  *
8160  * Returns whether fixed height mode is turned on for @tree_view.
8161  *
8162  * Return value: %TRUE if @tree_view is in fixed height mode
8163  *
8164  * Since: 2.6
8165  **/
8166 gboolean
8167 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
8168 {
8169   return tree_view->priv->fixed_height_mode;
8170 }
8171
8172 /* Returns TRUE if the focus is within the headers, after the focus operation is
8173  * done
8174  */
8175 static gboolean
8176 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
8177                             GtkDirectionType  dir,
8178                             gboolean          clamp_column_visible)
8179 {
8180   GtkTreeViewColumn *column;
8181   GtkWidget *focus_child;
8182   GtkWidget *button;
8183   GList *last_column, *first_column;
8184   GList *tmp_list;
8185   gboolean rtl;
8186
8187   if (! tree_view->priv->headers_visible)
8188     return FALSE;
8189
8190   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
8191
8192   first_column = tree_view->priv->columns;
8193   while (first_column)
8194     {
8195       column = GTK_TREE_VIEW_COLUMN (first_column->data);
8196       button = gtk_tree_view_column_get_button (column);
8197
8198       if (gtk_widget_get_can_focus (button) &&
8199           gtk_tree_view_column_get_visible (column) &&
8200           (gtk_tree_view_column_get_clickable (column) ||
8201            gtk_tree_view_column_get_reorderable (column)))
8202         break;
8203       first_column = first_column->next;
8204     }
8205
8206   /* No headers are visible, or are focusable.  We can't focus in or out.
8207    */
8208   if (first_column == NULL)
8209     return FALSE;
8210
8211   last_column = g_list_last (tree_view->priv->columns);
8212   while (last_column)
8213     {
8214       column = GTK_TREE_VIEW_COLUMN (last_column->data);
8215       button = gtk_tree_view_column_get_button (column);
8216
8217       if (gtk_widget_get_can_focus (button) &&
8218           gtk_tree_view_column_get_visible (column) &&
8219           (gtk_tree_view_column_get_clickable (column) ||
8220            gtk_tree_view_column_get_reorderable (column)))
8221         break;
8222       last_column = last_column->prev;
8223     }
8224
8225
8226   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8227
8228   switch (dir)
8229     {
8230     case GTK_DIR_TAB_BACKWARD:
8231     case GTK_DIR_TAB_FORWARD:
8232     case GTK_DIR_UP:
8233     case GTK_DIR_DOWN:
8234       if (focus_child == NULL)
8235         {
8236           if (tree_view->priv->focus_column != NULL)
8237             button = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8238           else
8239             button = NULL;
8240
8241           if (button && gtk_widget_get_can_focus (button))
8242             focus_child = button;
8243           else
8244             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8245
8246           gtk_widget_grab_focus (focus_child);
8247           break;
8248         }
8249       return FALSE;
8250
8251     case GTK_DIR_LEFT:
8252     case GTK_DIR_RIGHT:
8253       if (focus_child == NULL)
8254         {
8255           if (tree_view->priv->focus_column != NULL)
8256             focus_child = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8257           else if (dir == GTK_DIR_LEFT)
8258             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (last_column->data));
8259           else
8260             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8261
8262           gtk_widget_grab_focus (focus_child);
8263           break;
8264         }
8265
8266       if (gtk_widget_child_focus (focus_child, dir))
8267         {
8268           /* The focus moves inside the button. */
8269           /* This is probably a great example of bad UI */
8270           break;
8271         }
8272
8273       /* We need to move the focus among the row of buttons. */
8274       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8275         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8276           break;
8277
8278       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
8279           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
8280         {
8281           gtk_widget_error_bell (GTK_WIDGET (tree_view));
8282           break;
8283         }
8284
8285       while (tmp_list)
8286         {
8287           GtkTreeViewColumn *column;
8288           GtkWidget         *button;
8289
8290           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
8291             tmp_list = tmp_list->next;
8292           else
8293             tmp_list = tmp_list->prev;
8294
8295           if (tmp_list == NULL)
8296             {
8297               g_warning ("Internal button not found");
8298               break;
8299             }
8300           column = tmp_list->data;
8301           button = gtk_tree_view_column_get_button (column);
8302           if (button &&
8303               gtk_tree_view_column_get_visible (column) &&
8304               gtk_widget_get_can_focus (button))
8305             {
8306               focus_child = button;
8307               gtk_widget_grab_focus (button);
8308               break;
8309             }
8310         }
8311       break;
8312     default:
8313       g_assert_not_reached ();
8314       break;
8315     }
8316
8317   /* if focus child is non-null, we assume it's been set to the current focus child
8318    */
8319   if (focus_child)
8320     {
8321       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8322         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8323           {
8324             _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (tmp_list->data));
8325             break;
8326           }
8327
8328       if (clamp_column_visible)
8329         {
8330           gtk_tree_view_clamp_column_visible (tree_view,
8331                                               tree_view->priv->focus_column,
8332                                               FALSE);
8333         }
8334     }
8335
8336   return (focus_child != NULL);
8337 }
8338
8339 /* This function returns in 'path' the first focusable path, if the given path
8340  * is already focusable, it's the returned one.
8341  */
8342 static gboolean
8343 search_first_focusable_path (GtkTreeView  *tree_view,
8344                              GtkTreePath **path,
8345                              gboolean      search_forward,
8346                              GtkRBTree   **new_tree,
8347                              GtkRBNode   **new_node)
8348 {
8349   GtkRBTree *tree = NULL;
8350   GtkRBNode *node = NULL;
8351
8352   if (!path || !*path)
8353     return FALSE;
8354
8355   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
8356
8357   if (!tree || !node)
8358     return FALSE;
8359
8360   while (node && row_is_separator (tree_view, NULL, *path))
8361     {
8362       if (search_forward)
8363         _gtk_rbtree_next_full (tree, node, &tree, &node);
8364       else
8365         _gtk_rbtree_prev_full (tree, node, &tree, &node);
8366
8367       if (*path)
8368         gtk_tree_path_free (*path);
8369
8370       if (node)
8371         *path = _gtk_tree_path_new_from_rbtree (tree, node);
8372       else
8373         *path = NULL;
8374     }
8375
8376   if (new_tree)
8377     *new_tree = tree;
8378
8379   if (new_node)
8380     *new_node = node;
8381
8382   return (*path != NULL);
8383 }
8384
8385 static gint
8386 gtk_tree_view_focus (GtkWidget        *widget,
8387                      GtkDirectionType  direction)
8388 {
8389   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8390   GtkContainer *container = GTK_CONTAINER (widget);
8391   GtkWidget *focus_child;
8392
8393   if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
8394     return FALSE;
8395
8396   focus_child = gtk_container_get_focus_child (container);
8397
8398   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
8399   /* Case 1.  Headers currently have focus. */
8400   if (focus_child)
8401     {
8402       switch (direction)
8403         {
8404         case GTK_DIR_LEFT:
8405         case GTK_DIR_RIGHT:
8406           gtk_tree_view_header_focus (tree_view, direction, TRUE);
8407           return TRUE;
8408         case GTK_DIR_TAB_BACKWARD:
8409         case GTK_DIR_UP:
8410           return FALSE;
8411         case GTK_DIR_TAB_FORWARD:
8412         case GTK_DIR_DOWN:
8413           gtk_widget_grab_focus (widget);
8414           return TRUE;
8415         default:
8416           g_assert_not_reached ();
8417           return FALSE;
8418         }
8419     }
8420
8421   /* Case 2. We don't have focus at all. */
8422   if (!gtk_widget_has_focus (widget))
8423     {
8424       gtk_widget_grab_focus (widget);
8425       return TRUE;
8426     }
8427
8428   /* Case 3. We have focus already. */
8429   if (direction == GTK_DIR_TAB_BACKWARD)
8430     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
8431   else if (direction == GTK_DIR_TAB_FORWARD)
8432     return FALSE;
8433
8434   /* Other directions caught by the keybindings */
8435   gtk_widget_grab_focus (widget);
8436   return TRUE;
8437 }
8438
8439 static void
8440 gtk_tree_view_grab_focus (GtkWidget *widget)
8441 {
8442   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
8443
8444   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
8445 }
8446
8447 static void
8448 gtk_tree_view_style_updated (GtkWidget *widget)
8449 {
8450   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8451   GList *list;
8452   GtkTreeViewColumn *column;
8453
8454   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->style_updated (widget);
8455
8456   if (gtk_widget_get_realized (widget))
8457     {
8458       gtk_tree_view_ensure_background (tree_view);
8459
8460       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
8461       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
8462     }
8463
8464   gtk_widget_style_get (widget,
8465                         "expander-size", &tree_view->priv->expander_size,
8466                         NULL);
8467   tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
8468
8469   for (list = tree_view->priv->columns; list; list = list->next)
8470     {
8471       column = list->data;
8472       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8473     }
8474
8475   tree_view->priv->fixed_height = -1;
8476   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
8477
8478   gtk_widget_queue_resize (widget);
8479 }
8480
8481
8482 static void
8483 gtk_tree_view_set_focus_child (GtkContainer *container,
8484                                GtkWidget    *child)
8485 {
8486   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8487   GList *list;
8488
8489   for (list = tree_view->priv->columns; list; list = list->next)
8490     {
8491       if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child)
8492         {
8493           _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
8494           break;
8495         }
8496     }
8497
8498   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
8499 }
8500
8501 static GtkWidgetPath *
8502 gtk_tree_view_get_path_for_child (GtkContainer *container,
8503                                   GtkWidget    *child)
8504 {
8505   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8506   GtkWidgetPath *path;
8507   gboolean rtl;
8508   GList *list;
8509   gint n_col = 0;
8510
8511   path = GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->get_path_for_child (container, child);
8512   rtl = (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL);
8513
8514   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
8515        list;
8516        list = (rtl ? list->prev : list->next))
8517     {
8518       GtkTreeViewColumn *column = list->data;
8519       GtkRegionFlags flags = 0;
8520
8521       if (!gtk_tree_view_column_get_visible (column))
8522         continue;
8523
8524       n_col++;
8525
8526       if (gtk_tree_view_column_get_widget (column) != child &&
8527           gtk_tree_view_column_get_button (column) != child)
8528         continue;
8529
8530       if ((n_col % 2) == 0)
8531         flags |= GTK_REGION_EVEN;
8532       else
8533         flags |= GTK_REGION_ODD;
8534
8535       if (n_col == 1)
8536         flags |= GTK_REGION_FIRST;
8537
8538       if ((rtl && !list->prev) ||
8539           (!rtl && !list->next))
8540         flags |= GTK_REGION_LAST;
8541
8542       gtk_widget_path_iter_add_region (path, -1, GTK_STYLE_REGION_COLUMN_HEADER, flags);
8543       break;
8544     }
8545
8546   gtk_widget_path_append_for_widget (path, child);
8547
8548   return path;
8549 }
8550
8551 static gboolean
8552 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8553                                 GtkMovementStep    step,
8554                                 gint               count)
8555 {
8556   GdkModifierType state;
8557
8558   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8559   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8560                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8561                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8562                         step == GTK_MOVEMENT_PAGES ||
8563                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8564
8565   if (tree_view->priv->tree == NULL)
8566     return FALSE;
8567   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8568     return FALSE;
8569
8570   gtk_tree_view_stop_editing (tree_view, FALSE);
8571   tree_view->priv->draw_keyfocus = TRUE;
8572   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8573
8574   if (gtk_get_current_event_state (&state))
8575     {
8576       GdkModifierType extend_mod_mask;
8577       GdkModifierType modify_mod_mask;
8578
8579       extend_mod_mask =
8580         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8581                                       GDK_MODIFIER_INTENT_EXTEND_SELECTION);
8582
8583       modify_mod_mask =
8584         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8585                                       GDK_MODIFIER_INTENT_MODIFY_SELECTION);
8586
8587       if ((state & modify_mod_mask) == modify_mod_mask)
8588         tree_view->priv->modify_selection_pressed = TRUE;
8589       if ((state & extend_mod_mask) == extend_mod_mask)
8590         tree_view->priv->extend_selection_pressed = TRUE;
8591     }
8592   /* else we assume not pressed */
8593
8594   switch (step)
8595     {
8596       /* currently we make no distinction.  When we go bi-di, we need to */
8597     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8598     case GTK_MOVEMENT_VISUAL_POSITIONS:
8599       gtk_tree_view_move_cursor_left_right (tree_view, count);
8600       break;
8601     case GTK_MOVEMENT_DISPLAY_LINES:
8602       gtk_tree_view_move_cursor_up_down (tree_view, count);
8603       break;
8604     case GTK_MOVEMENT_PAGES:
8605       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8606       break;
8607     case GTK_MOVEMENT_BUFFER_ENDS:
8608       gtk_tree_view_move_cursor_start_end (tree_view, count);
8609       break;
8610     default:
8611       g_assert_not_reached ();
8612     }
8613
8614   tree_view->priv->modify_selection_pressed = FALSE;
8615   tree_view->priv->extend_selection_pressed = FALSE;
8616
8617   return TRUE;
8618 }
8619
8620 static void
8621 gtk_tree_view_put (GtkTreeView *tree_view,
8622                    GtkWidget   *child_widget,
8623                    /* in bin_window coordinates */
8624                    gint         x,
8625                    gint         y,
8626                    gint         width,
8627                    gint         height)
8628 {
8629   GtkTreeViewChild *child;
8630
8631   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8632   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8633
8634   child = g_slice_new (GtkTreeViewChild);
8635
8636   child->widget = child_widget;
8637   child->x = x;
8638   child->y = y;
8639   child->width = width;
8640   child->height = height;
8641
8642   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8643
8644   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8645     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8646
8647   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8648 }
8649
8650 void
8651 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8652                                   GtkWidget   *widget,
8653                                   /* in tree coordinates */
8654                                   gint         x,
8655                                   gint         y,
8656                                   gint         width,
8657                                   gint         height)
8658 {
8659   GtkTreeViewChild *child = NULL;
8660   GList *list;
8661   GdkRectangle allocation;
8662
8663   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8664   g_return_if_fail (GTK_IS_WIDGET (widget));
8665
8666   for (list = tree_view->priv->children; list; list = list->next)
8667     {
8668       if (((GtkTreeViewChild *)list->data)->widget == widget)
8669         {
8670           child = list->data;
8671           break;
8672         }
8673     }
8674   if (child == NULL)
8675     return;
8676
8677   allocation.x = child->x = x;
8678   allocation.y = child->y = y;
8679   allocation.width = child->width = width;
8680   allocation.height = child->height = height;
8681
8682   if (gtk_widget_get_realized (widget))
8683     gtk_widget_size_allocate (widget, &allocation);
8684 }
8685
8686
8687 /* TreeModel Callbacks
8688  */
8689
8690 static void
8691 gtk_tree_view_row_changed (GtkTreeModel *model,
8692                            GtkTreePath  *path,
8693                            GtkTreeIter  *iter,
8694                            gpointer      data)
8695 {
8696   GtkTreeView *tree_view = (GtkTreeView *)data;
8697   GtkRBTree *tree;
8698   GtkRBNode *node;
8699   gboolean free_path = FALSE;
8700   GList *list;
8701   GtkTreePath *cursor_path;
8702
8703   g_return_if_fail (path != NULL || iter != NULL);
8704
8705   if (tree_view->priv->cursor_node != NULL)
8706     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
8707                                                   tree_view->priv->cursor_node);
8708   else
8709     cursor_path = NULL;
8710
8711   if (tree_view->priv->edited_column &&
8712       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8713     gtk_tree_view_stop_editing (tree_view, TRUE);
8714
8715   if (cursor_path != NULL)
8716     gtk_tree_path_free (cursor_path);
8717
8718   if (path == NULL)
8719     {
8720       path = gtk_tree_model_get_path (model, iter);
8721       free_path = TRUE;
8722     }
8723   else if (iter == NULL)
8724     gtk_tree_model_get_iter (model, iter, path);
8725
8726   if (_gtk_tree_view_find_node (tree_view,
8727                                 path,
8728                                 &tree,
8729                                 &node))
8730     /* We aren't actually showing the node */
8731     goto done;
8732
8733   if (tree == NULL)
8734     goto done;
8735
8736   _gtk_tree_view_accessible_changed (tree_view, tree, node);
8737
8738   if (tree_view->priv->fixed_height_mode
8739       && tree_view->priv->fixed_height >= 0)
8740     {
8741       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8742       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8743         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8744     }
8745   else
8746     {
8747       _gtk_rbtree_node_mark_invalid (tree, node);
8748       for (list = tree_view->priv->columns; list; list = list->next)
8749         {
8750           GtkTreeViewColumn *column;
8751
8752           column = list->data;
8753           if (!gtk_tree_view_column_get_visible (column))
8754             continue;
8755
8756           if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8757             {
8758               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8759             }
8760         }
8761     }
8762
8763  done:
8764   if (!tree_view->priv->fixed_height_mode &&
8765       gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8766     install_presize_handler (tree_view);
8767   if (free_path)
8768     gtk_tree_path_free (path);
8769 }
8770
8771 static void
8772 gtk_tree_view_row_inserted (GtkTreeModel *model,
8773                             GtkTreePath  *path,
8774                             GtkTreeIter  *iter,
8775                             gpointer      data)
8776 {
8777   GtkTreeView *tree_view = (GtkTreeView *) data;
8778   gint *indices;
8779   GtkRBTree *tree;
8780   GtkRBNode *tmpnode = NULL;
8781   gint depth;
8782   gint i = 0;
8783   gint height;
8784   gboolean free_path = FALSE;
8785   gboolean node_visible = TRUE;
8786
8787   g_return_if_fail (path != NULL || iter != NULL);
8788
8789   if (tree_view->priv->fixed_height_mode
8790       && tree_view->priv->fixed_height >= 0)
8791     height = tree_view->priv->fixed_height;
8792   else
8793     height = 0;
8794
8795   if (path == NULL)
8796     {
8797       path = gtk_tree_model_get_path (model, iter);
8798       free_path = TRUE;
8799     }
8800   else if (iter == NULL)
8801     gtk_tree_model_get_iter (model, iter, path);
8802
8803   if (tree_view->priv->tree == NULL)
8804     tree_view->priv->tree = _gtk_rbtree_new ();
8805
8806   tree = tree_view->priv->tree;
8807
8808   /* Update all row-references */
8809   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8810   depth = gtk_tree_path_get_depth (path);
8811   indices = gtk_tree_path_get_indices (path);
8812
8813   /* First, find the parent tree */
8814   while (i < depth - 1)
8815     {
8816       if (tree == NULL)
8817         {
8818           /* We aren't showing the node */
8819           node_visible = FALSE;
8820           goto done;
8821         }
8822
8823       tmpnode = _gtk_rbtree_find_count (tree, indices[i] + 1);
8824       if (tmpnode == NULL)
8825         {
8826           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8827                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8828                      "before the parent was inserted.");
8829           goto done;
8830         }
8831       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8832         {
8833           /* FIXME enforce correct behavior on model, probably */
8834           /* In theory, the model should have emitted has_child_toggled here.  We
8835            * try to catch it anyway, just to be safe, in case the model hasn't.
8836            */
8837           GtkTreePath *tmppath = _gtk_tree_path_new_from_rbtree (tree, tmpnode);
8838           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8839           gtk_tree_path_free (tmppath);
8840           goto done;
8841         }
8842
8843       tree = tmpnode->children;
8844       i++;
8845     }
8846
8847   if (tree == NULL)
8848     {
8849       node_visible = FALSE;
8850       goto done;
8851     }
8852
8853   /* ref the node */
8854   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8855   if (indices[depth - 1] == 0)
8856     {
8857       tmpnode = _gtk_rbtree_find_count (tree, 1);
8858       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8859     }
8860   else
8861     {
8862       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8863       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8864     }
8865
8866   _gtk_tree_view_accessible_add (tree_view, tree, tmpnode);
8867
8868  done:
8869   if (height > 0)
8870     {
8871       if (tree)
8872         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8873
8874       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8875         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8876       else
8877         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8878     }
8879   else
8880     install_presize_handler (tree_view);
8881   if (free_path)
8882     gtk_tree_path_free (path);
8883 }
8884
8885 static void
8886 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8887                                      GtkTreePath  *path,
8888                                      GtkTreeIter  *iter,
8889                                      gpointer      data)
8890 {
8891   GtkTreeView *tree_view = (GtkTreeView *)data;
8892   GtkTreeIter real_iter;
8893   gboolean has_child;
8894   GtkRBTree *tree;
8895   GtkRBNode *node;
8896   gboolean free_path = FALSE;
8897
8898   g_return_if_fail (path != NULL || iter != NULL);
8899
8900   if (iter)
8901     real_iter = *iter;
8902
8903   if (path == NULL)
8904     {
8905       path = gtk_tree_model_get_path (model, iter);
8906       free_path = TRUE;
8907     }
8908   else if (iter == NULL)
8909     gtk_tree_model_get_iter (model, &real_iter, path);
8910
8911   if (_gtk_tree_view_find_node (tree_view,
8912                                 path,
8913                                 &tree,
8914                                 &node))
8915     /* We aren't actually showing the node */
8916     goto done;
8917
8918   if (tree == NULL)
8919     goto done;
8920
8921   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8922   /* Sanity check.
8923    */
8924   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8925     goto done;
8926
8927   if (has_child)
8928     {
8929       GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8930       _gtk_tree_view_accessible_add_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8931     }
8932   else
8933     {
8934       GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8935       _gtk_tree_view_accessible_remove_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8936     }
8937
8938   if (has_child && tree_view->priv->is_list)
8939     {
8940       tree_view->priv->is_list = FALSE;
8941       if (tree_view->priv->show_expanders)
8942         {
8943           GList *list;
8944
8945           for (list = tree_view->priv->columns; list; list = list->next)
8946             if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
8947               {
8948                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8949                 break;
8950               }
8951         }
8952       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8953     }
8954   else
8955     {
8956       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8957     }
8958
8959  done:
8960   if (free_path)
8961     gtk_tree_path_free (path);
8962 }
8963
8964 static void
8965 count_children_helper (GtkRBTree *tree,
8966                        GtkRBNode *node,
8967                        gpointer   data)
8968 {
8969   if (node->children)
8970     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8971   (*((gint *)data))++;
8972 }
8973
8974 static void
8975 check_selection_helper (GtkRBTree *tree,
8976                         GtkRBNode *node,
8977                         gpointer   data)
8978 {
8979   gint *value = (gint *)data;
8980
8981   *value |= GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8982
8983   if (node->children && !*value)
8984     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8985 }
8986
8987 static void
8988 gtk_tree_view_row_deleted (GtkTreeModel *model,
8989                            GtkTreePath  *path,
8990                            gpointer      data)
8991 {
8992   GtkTreeView *tree_view = (GtkTreeView *)data;
8993   GtkRBTree *tree;
8994   GtkRBNode *node;
8995   GList *list;
8996   gboolean selection_changed = FALSE, cursor_changed = FALSE;
8997   GtkRBTree *cursor_tree = NULL;
8998   GtkRBNode *cursor_node = NULL;
8999   GtkStyleContext *context;
9000
9001   g_return_if_fail (path != NULL);
9002
9003   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
9004
9005   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
9006     return;
9007
9008   if (tree == NULL)
9009     return;
9010
9011   /* check if the selection has been changed */
9012   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
9013                         check_selection_helper, &selection_changed);
9014
9015   for (list = tree_view->priv->columns; list; list = list->next)
9016     if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)) &&
9017         gtk_tree_view_column_get_sizing (GTK_TREE_VIEW_COLUMN (list->data)) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9018       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
9019
9020   /* Ensure we don't have a dangling pointer to a dead node */
9021   ensure_unprelighted (tree_view);
9022
9023   /* Cancel editting if we've started */
9024   gtk_tree_view_stop_editing (tree_view, TRUE);
9025
9026   /* If the cursor row got deleted, move the cursor to the next row */
9027   if (tree_view->priv->cursor_node &&
9028       (tree_view->priv->cursor_node == node ||
9029        (node->children && (tree_view->priv->cursor_tree == node->children ||
9030                            _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree)))))
9031     {
9032       GtkTreePath *cursor_path;
9033
9034       cursor_tree = tree;
9035       cursor_node = _gtk_rbtree_next (tree, node);
9036       /* find the first node that is not going to be deleted */
9037       while (cursor_node == NULL && cursor_tree->parent_tree)
9038         {
9039           cursor_node = _gtk_rbtree_next (cursor_tree->parent_tree,
9040                                           cursor_tree->parent_node);
9041           cursor_tree = cursor_tree->parent_tree;
9042         }
9043
9044       if (cursor_node != NULL)
9045         cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9046       else
9047         cursor_path = NULL;
9048
9049       if (cursor_path == NULL ||
9050           ! search_first_focusable_path (tree_view, &cursor_path, TRUE,
9051                                          &cursor_tree, &cursor_node))
9052         {
9053           /* It looks like we reached the end of the view without finding
9054            * a focusable row.  We will step backwards to find the last
9055            * focusable row.
9056            */
9057           _gtk_rbtree_prev_full (tree, node, &cursor_tree, &cursor_node);
9058           if (cursor_node)
9059             {
9060               cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9061               if (! search_first_focusable_path (tree_view, &cursor_path, FALSE,
9062                                                  &cursor_tree, &cursor_node))
9063                 cursor_node = NULL;
9064               gtk_tree_path_free (cursor_path);
9065             }
9066         }
9067       else if (cursor_path)
9068         gtk_tree_path_free (cursor_path);
9069
9070       cursor_changed = TRUE;
9071     }
9072
9073   if (tree_view->priv->destroy_count_func)
9074     {
9075       gint child_count = 0;
9076       if (node->children)
9077         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
9078       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
9079     }
9080
9081   if (tree->root->count == 1)
9082     {
9083       if (tree_view->priv->tree == tree)
9084         tree_view->priv->tree = NULL;
9085
9086       _gtk_tree_view_accessible_remove_state (tree_view,
9087                                               tree->parent_tree, tree->parent_node,
9088                                               GTK_CELL_RENDERER_EXPANDED);
9089       _gtk_tree_view_accessible_remove (tree_view, tree, NULL);
9090       _gtk_rbtree_remove (tree);
9091     }
9092   else
9093     {
9094       _gtk_tree_view_accessible_remove (tree_view, tree, node);
9095       _gtk_rbtree_remove_node (tree, node);
9096     }
9097
9098   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
9099     {
9100       gtk_tree_row_reference_free (tree_view->priv->top_row);
9101       tree_view->priv->top_row = NULL;
9102     }
9103
9104   /* Cancel any ongoing animation happening within the row */
9105   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
9106   gtk_style_context_cancel_animations (context, node);
9107
9108   install_scroll_sync_handler (tree_view);
9109
9110   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9111
9112   if (cursor_changed)
9113     {
9114       if (cursor_node)
9115         {
9116           GtkTreePath *cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9117           gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CURSOR_INVALID);
9118           gtk_tree_path_free (cursor_path);
9119         }
9120       else
9121         gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT | CURSOR_INVALID);
9122     }
9123   if (selection_changed)
9124     g_signal_emit_by_name (tree_view->priv->selection, "changed");
9125 }
9126
9127 static void
9128 gtk_tree_view_rows_reordered (GtkTreeModel *model,
9129                               GtkTreePath  *parent,
9130                               GtkTreeIter  *iter,
9131                               gint         *new_order,
9132                               gpointer      data)
9133 {
9134   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
9135   GtkRBTree *tree;
9136   GtkRBNode *node;
9137   gint len;
9138
9139   len = gtk_tree_model_iter_n_children (model, iter);
9140
9141   if (len < 2)
9142     return;
9143
9144   gtk_tree_row_reference_reordered (G_OBJECT (data),
9145                                     parent,
9146                                     iter,
9147                                     new_order);
9148
9149   if (_gtk_tree_view_find_node (tree_view,
9150                                 parent,
9151                                 &tree,
9152                                 &node))
9153     return;
9154
9155   /* We need to special case the parent path */
9156   if (tree == NULL)
9157     tree = tree_view->priv->tree;
9158   else
9159     tree = node->children;
9160
9161   if (tree == NULL)
9162     return;
9163
9164   if (tree_view->priv->edited_column)
9165     gtk_tree_view_stop_editing (tree_view, TRUE);
9166
9167   /* we need to be unprelighted */
9168   ensure_unprelighted (tree_view);
9169
9170   _gtk_rbtree_reorder (tree, new_order, len);
9171
9172   _gtk_tree_view_accessible_reorder (tree_view);
9173
9174   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
9175
9176   gtk_tree_view_dy_to_top_row (tree_view);
9177 }
9178
9179
9180 /* Internal tree functions
9181  */
9182
9183
9184 static void
9185 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
9186                                      GtkRBTree         *tree,
9187                                      GtkTreeViewColumn *column,
9188                                      gint              *x1,
9189                                      gint              *x2)
9190 {
9191   GtkTreeViewColumn *tmp_column = NULL;
9192   gint total_width;
9193   GList *list;
9194   gboolean rtl;
9195
9196   if (x1)
9197     *x1 = 0;
9198
9199   if (x2)
9200     *x2 = 0;
9201
9202   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9203
9204   total_width = 0;
9205   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9206        list;
9207        list = (rtl ? list->prev : list->next))
9208     {
9209       tmp_column = list->data;
9210
9211       if (tmp_column == column)
9212         break;
9213
9214       if (gtk_tree_view_column_get_visible (tmp_column))
9215         total_width += gtk_tree_view_column_get_width (tmp_column);
9216     }
9217
9218   if (tmp_column != column)
9219     {
9220       g_warning (G_STRLOC": passed-in column isn't in the tree");
9221       return;
9222     }
9223
9224   if (x1)
9225     *x1 = total_width;
9226
9227   if (x2)
9228     {
9229       if (gtk_tree_view_column_get_visible (column))
9230         *x2 = total_width + gtk_tree_view_column_get_width (column);
9231       else
9232         *x2 = total_width; /* width of 0 */
9233     }
9234 }
9235
9236 static void
9237 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
9238                                 GtkRBTree   *tree,
9239                                 gint        *x1,
9240                                 gint        *x2)
9241 {
9242   gint x_offset = 0;
9243   GList *list;
9244   GtkTreeViewColumn *tmp_column = NULL;
9245   gint total_width;
9246   gboolean indent_expanders;
9247   gboolean rtl;
9248
9249   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9250
9251   total_width = 0;
9252   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9253        list;
9254        list = (rtl ? list->prev : list->next))
9255     {
9256       tmp_column = list->data;
9257
9258       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
9259         {
9260           if (rtl)
9261             x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - tree_view->priv->expander_size;
9262           else
9263             x_offset = total_width;
9264           break;
9265         }
9266
9267       if (gtk_tree_view_column_get_visible (tmp_column))
9268         total_width += gtk_tree_view_column_get_width (tmp_column);
9269     }
9270
9271   gtk_widget_style_get (GTK_WIDGET (tree_view),
9272                         "indent-expanders", &indent_expanders,
9273                         NULL);
9274
9275   if (indent_expanders)
9276     {
9277       if (rtl)
9278         x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
9279       else
9280         x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
9281     }
9282
9283   *x1 = x_offset;
9284
9285   if (tmp_column &&
9286       gtk_tree_view_column_get_visible (tmp_column))
9287     /* +1 because x2 isn't included in the range. */
9288     *x2 = *x1 + tree_view->priv->expander_size + 1;
9289   else
9290     *x2 = *x1;
9291 }
9292
9293 static void
9294 gtk_tree_view_build_tree (GtkTreeView *tree_view,
9295                           GtkRBTree   *tree,
9296                           GtkTreeIter *iter,
9297                           gint         depth,
9298                           gboolean     recurse)
9299 {
9300   GtkRBNode *temp = NULL;
9301   GtkTreePath *path = NULL;
9302
9303   do
9304     {
9305       gtk_tree_model_ref_node (tree_view->priv->model, iter);
9306       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
9307
9308       if (tree_view->priv->fixed_height > 0)
9309         {
9310           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
9311             {
9312               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
9313               _gtk_rbtree_node_mark_valid (tree, temp);
9314             }
9315         }
9316
9317       if (tree_view->priv->is_list)
9318         continue;
9319
9320       if (recurse)
9321         {
9322           GtkTreeIter child;
9323
9324           if (!path)
9325             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
9326           else
9327             gtk_tree_path_next (path);
9328
9329           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
9330             {
9331               gboolean expand;
9332
9333               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
9334
9335               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
9336                   && !expand)
9337                 {
9338                   temp->children = _gtk_rbtree_new ();
9339                   temp->children->parent_tree = tree;
9340                   temp->children->parent_node = temp;
9341                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
9342                 }
9343             }
9344         }
9345
9346       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
9347         {
9348           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
9349             temp->flags ^= GTK_RBNODE_IS_PARENT;
9350         }
9351     }
9352   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
9353
9354   if (path)
9355     gtk_tree_path_free (path);
9356 }
9357
9358 /* Make sure the node is visible vertically */
9359 static void
9360 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
9361                                   GtkRBTree   *tree,
9362                                   GtkRBNode   *node)
9363 {
9364   gint node_dy, height;
9365   GtkTreePath *path = NULL;
9366
9367   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9368     return;
9369
9370   /* just return if the node is visible, avoiding a costly expose */
9371   node_dy = _gtk_rbtree_node_find_offset (tree, node);
9372   height = gtk_tree_view_get_row_height (tree_view, node);
9373   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
9374       && node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment)
9375       && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
9376                               + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
9377     return;
9378
9379   path = _gtk_tree_path_new_from_rbtree (tree, node);
9380   if (path)
9381     {
9382       /* We process updates because we want to clear old selected items when we scroll.
9383        * if this is removed, we get a "selection streak" at the bottom. */
9384       gtk_tree_view_bin_process_updates (tree_view);
9385
9386       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
9387       gtk_tree_path_free (path);
9388     }
9389 }
9390
9391 static void
9392 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
9393                                     GtkTreeViewColumn *column,
9394                                     gboolean           focus_to_cell)
9395 {
9396   GtkAllocation allocation;
9397   gint x, width;
9398
9399   if (column == NULL)
9400     return;
9401
9402   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
9403   x = allocation.x;
9404   width = allocation.width;
9405
9406   if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9407     {
9408       /* The column is larger than the horizontal page size.  If the
9409        * column has cells which can be focussed individually, then we make
9410        * sure the cell which gets focus is fully visible (if even the
9411        * focus cell is bigger than the page size, we make sure the
9412        * left-hand side of the cell is visible).
9413        *
9414        * If the column does not have an activatable cell, we
9415        * make sure the left-hand side of the column is visible.
9416        */
9417
9418       if (focus_to_cell && gtk_tree_view_has_can_focus_cell (tree_view))
9419         {
9420           GtkCellArea *cell_area;
9421           GtkCellRenderer *focus_cell;
9422
9423           cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
9424           focus_cell = gtk_cell_area_get_focus_cell (cell_area);
9425
9426           if (gtk_tree_view_column_cell_get_position (column, focus_cell,
9427                                                       &x, &width))
9428             {
9429               if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9430                 {
9431                   if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment) < x + width)
9432                     gtk_adjustment_set_value (tree_view->priv->hadjustment,
9433                                               x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9434                   else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9435                     gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9436                 }
9437             }
9438         }
9439
9440       gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9441     }
9442   else
9443     {
9444       if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
9445           gtk_adjustment_set_value (tree_view->priv->hadjustment,
9446                                     x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9447       else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9448         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9449   }
9450 }
9451
9452 /* This function could be more efficient.  I'll optimize it if profiling seems
9453  * to imply that it is important */
9454 GtkTreePath *
9455 _gtk_tree_path_new_from_rbtree (GtkRBTree   *tree,
9456                                 GtkRBNode   *node)
9457 {
9458   GtkTreePath *path;
9459   GtkRBTree *tmp_tree;
9460   GtkRBNode *tmp_node, *last;
9461   gint count;
9462
9463   path = gtk_tree_path_new ();
9464
9465   g_return_val_if_fail (node != NULL, path);
9466
9467   count = 1 + node->left->count;
9468
9469   last = node;
9470   tmp_node = node->parent;
9471   tmp_tree = tree;
9472   while (tmp_tree)
9473     {
9474       while (!_gtk_rbtree_is_nil (tmp_node))
9475         {
9476           if (tmp_node->right == last)
9477             count += 1 + tmp_node->left->count;
9478           last = tmp_node;
9479           tmp_node = tmp_node->parent;
9480         }
9481       gtk_tree_path_prepend_index (path, count - 1);
9482       last = tmp_tree->parent_node;
9483       tmp_tree = tmp_tree->parent_tree;
9484       if (last)
9485         {
9486           count = 1 + last->left->count;
9487           tmp_node = last->parent;
9488         }
9489     }
9490   return path;
9491 }
9492
9493 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
9494  * invalid (ie. points to a node that's not in the tree), *tree and *node are
9495  * both set to NULL.
9496  */
9497 gboolean
9498 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
9499                           GtkTreePath  *path,
9500                           GtkRBTree   **tree,
9501                           GtkRBNode   **node)
9502 {
9503   GtkRBNode *tmpnode = NULL;
9504   GtkRBTree *tmptree = tree_view->priv->tree;
9505   gint *indices = gtk_tree_path_get_indices (path);
9506   gint depth = gtk_tree_path_get_depth (path);
9507   gint i = 0;
9508
9509   *node = NULL;
9510   *tree = NULL;
9511
9512   if (depth == 0 || tmptree == NULL)
9513     return FALSE;
9514   do
9515     {
9516       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
9517       ++i;
9518       if (tmpnode == NULL)
9519         {
9520           *tree = NULL;
9521           *node = NULL;
9522           return FALSE;
9523         }
9524       if (i >= depth)
9525         {
9526           *tree = tmptree;
9527           *node = tmpnode;
9528           return FALSE;
9529         }
9530       *tree = tmptree;
9531       *node = tmpnode;
9532       tmptree = tmpnode->children;
9533       if (tmptree == NULL)
9534         return TRUE;
9535     }
9536   while (1);
9537 }
9538
9539 static gboolean
9540 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9541                                   GtkTreeViewColumn *column)
9542 {
9543   GList *list;
9544
9545   if (tree_view->priv->is_list)
9546     return FALSE;
9547
9548   if (tree_view->priv->expander_column != NULL)
9549     {
9550       if (tree_view->priv->expander_column == column)
9551         return TRUE;
9552       return FALSE;
9553     }
9554   else
9555     {
9556       for (list = tree_view->priv->columns;
9557            list;
9558            list = list->next)
9559         if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
9560           break;
9561       if (list && list->data == column)
9562         return TRUE;
9563     }
9564   return FALSE;
9565 }
9566
9567 static inline gboolean
9568 gtk_tree_view_draw_expanders (GtkTreeView *tree_view)
9569 {
9570   if (!tree_view->priv->is_list && tree_view->priv->show_expanders)
9571     return TRUE;
9572   /* else */
9573   return FALSE;
9574 }
9575
9576 static void
9577 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9578                                 guint           keyval,
9579                                 guint           modmask,
9580                                 gboolean        add_shifted_binding,
9581                                 GtkMovementStep step,
9582                                 gint            count)
9583 {
9584
9585   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9586                                 "move-cursor", 2,
9587                                 G_TYPE_ENUM, step,
9588                                 G_TYPE_INT, count);
9589
9590   if (add_shifted_binding)
9591     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9592                                   "move-cursor", 2,
9593                                   G_TYPE_ENUM, step,
9594                                   G_TYPE_INT, count);
9595
9596   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9597    return;
9598
9599   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9600                                 "move-cursor", 2,
9601                                 G_TYPE_ENUM, step,
9602                                 G_TYPE_INT, count);
9603
9604   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9605                                 "move-cursor", 2,
9606                                 G_TYPE_ENUM, step,
9607                                 G_TYPE_INT, count);
9608 }
9609
9610 static gint
9611 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9612                                  GtkTreeIter  *iter,
9613                                  GtkRBTree    *tree,
9614                                  GtkRBNode    *node)
9615 {
9616   gint retval = FALSE;
9617   do
9618     {
9619       g_return_val_if_fail (node != NULL, FALSE);
9620
9621       if (node->children)
9622         {
9623           GtkTreeIter child;
9624           GtkRBTree *new_tree;
9625           GtkRBNode *new_node;
9626
9627           new_tree = node->children;
9628           new_node = _gtk_rbtree_first (new_tree);
9629
9630           if (!gtk_tree_model_iter_children (model, &child, iter))
9631             return FALSE;
9632
9633           retval = gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node) | retval;
9634         }
9635
9636       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9637         retval = TRUE;
9638       gtk_tree_model_unref_node (model, iter);
9639       node = _gtk_rbtree_next (tree, node);
9640     }
9641   while (gtk_tree_model_iter_next (model, iter));
9642
9643   return retval;
9644 }
9645
9646 static gint
9647 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9648                                               GtkRBTree   *tree)
9649 {
9650   GtkTreeIter iter;
9651   GtkTreePath *path;
9652   GtkRBNode *node;
9653   gint retval;
9654
9655   if (!tree)
9656     return FALSE;
9657
9658   node = _gtk_rbtree_first (tree);
9659
9660   g_return_val_if_fail (node != NULL, FALSE);
9661   path = _gtk_tree_path_new_from_rbtree (tree, node);
9662   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9663                            &iter, path);
9664   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9665   gtk_tree_path_free (path);
9666
9667   return retval;
9668 }
9669
9670 static void
9671 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9672                                     GtkTreeViewColumn *column)
9673 {
9674   GtkTreeViewColumn *left_column;
9675   GtkTreeViewColumn *cur_column = NULL;
9676   GtkTreeViewColumnReorder *reorder;
9677   gboolean rtl;
9678   GList *tmp_list;
9679   gint left;
9680
9681   /* We want to precalculate the motion list such that we know what column slots
9682    * are available.
9683    */
9684   left_column = NULL;
9685   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9686
9687   /* First, identify all possible drop spots */
9688   if (rtl)
9689     tmp_list = g_list_last (tree_view->priv->columns);
9690   else
9691     tmp_list = g_list_first (tree_view->priv->columns);
9692
9693   while (tmp_list)
9694     {
9695       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9696       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9697
9698       if (gtk_tree_view_column_get_visible (cur_column) == FALSE)
9699         continue;
9700
9701       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9702       if (left_column != column && cur_column != column &&
9703           tree_view->priv->column_drop_func &&
9704           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9705         {
9706           left_column = cur_column;
9707           continue;
9708         }
9709       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9710       reorder->left_column = left_column;
9711       left_column = reorder->right_column = cur_column;
9712
9713       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9714     }
9715
9716   /* Add the last one */
9717   if (tree_view->priv->column_drop_func == NULL ||
9718       ((left_column != column) &&
9719        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9720     {
9721       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9722       reorder->left_column = left_column;
9723       reorder->right_column = NULL;
9724       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9725     }
9726
9727   /* We quickly check to see if it even makes sense to reorder columns. */
9728   /* If there is nothing that can be moved, then we return */
9729
9730   if (tree_view->priv->column_drag_info == NULL)
9731     return;
9732
9733   /* We know there are always 2 slots possbile, as you can always return column. */
9734   /* If that's all there is, return */
9735   if (tree_view->priv->column_drag_info->next == NULL ||
9736       (tree_view->priv->column_drag_info->next->next == NULL &&
9737        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9738        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9739     {
9740       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9741         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9742       g_list_free (tree_view->priv->column_drag_info);
9743       tree_view->priv->column_drag_info = NULL;
9744       return;
9745     }
9746   /* We fill in the ranges for the columns, now that we've isolated them */
9747   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9748
9749   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9750     {
9751       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9752
9753       reorder->left_align = left;
9754       if (tmp_list->next != NULL)
9755         {
9756           GtkAllocation right_allocation, left_allocation;
9757           GtkWidget    *left_button, *right_button;
9758
9759           g_assert (tmp_list->next->data);
9760
9761           right_button = gtk_tree_view_column_get_button (reorder->right_column);
9762           left_button  = gtk_tree_view_column_get_button
9763             (((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column);
9764
9765           gtk_widget_get_allocation (right_button, &right_allocation);
9766           gtk_widget_get_allocation (left_button, &left_allocation);
9767           left = reorder->right_align = (right_allocation.x + right_allocation.width + left_allocation.x) / 2;
9768         }
9769       else
9770         {
9771           reorder->right_align = gdk_window_get_width (tree_view->priv->header_window)
9772                                  + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9773         }
9774     }
9775 }
9776
9777 void
9778 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9779                                   GtkTreeViewColumn *column,
9780                                   GdkDevice         *device)
9781 {
9782   GdkEvent *send_event;
9783   GtkAllocation allocation;
9784   GtkAllocation button_allocation;
9785   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9786   GtkWidget *button;
9787   GdkDevice *pointer, *keyboard;
9788
9789   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9790   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9791
9792   gtk_tree_view_set_column_drag_info (tree_view, column);
9793
9794   if (tree_view->priv->column_drag_info == NULL)
9795     return;
9796
9797   button = gtk_tree_view_column_get_button (column);
9798
9799   if (tree_view->priv->drag_window == NULL)
9800     {
9801       GdkWindowAttr attributes;
9802       guint attributes_mask;
9803
9804       gtk_widget_get_allocation (button, &button_allocation);
9805
9806       attributes.window_type = GDK_WINDOW_CHILD;
9807       attributes.wclass = GDK_INPUT_OUTPUT;
9808       attributes.x = button_allocation.x;
9809       attributes.y = 0;
9810       attributes.width = button_allocation.width;
9811       attributes.height = button_allocation.height;
9812       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9813       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9814       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
9815
9816       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
9817                                                      &attributes,
9818                                                      attributes_mask);
9819       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
9820     }
9821
9822   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
9823     {
9824       keyboard = device;
9825       pointer = gdk_device_get_associated_device (device);
9826     }
9827   else
9828     {
9829       pointer = device;
9830       keyboard = gdk_device_get_associated_device (device);
9831     }
9832
9833   gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
9834   gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);
9835
9836   gtk_grab_remove (button);
9837
9838   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9839   send_event->crossing.send_event = TRUE;
9840   send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (button)));
9841   send_event->crossing.subwindow = NULL;
9842   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9843   send_event->crossing.time = GDK_CURRENT_TIME;
9844   gdk_event_set_device (send_event, device);
9845
9846   gtk_propagate_event (button, send_event);
9847   gdk_event_free (send_event);
9848
9849   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9850   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9851   send_event->button.send_event = TRUE;
9852   send_event->button.time = GDK_CURRENT_TIME;
9853   send_event->button.x = -1;
9854   send_event->button.y = -1;
9855   send_event->button.axes = NULL;
9856   send_event->button.state = 0;
9857   send_event->button.button = GDK_BUTTON_PRIMARY;
9858   send_event->button.x_root = 0;
9859   send_event->button.y_root = 0;
9860   gdk_event_set_device (send_event, device);
9861
9862   gtk_propagate_event (button, send_event);
9863   gdk_event_free (send_event);
9864
9865   /* Kids, don't try this at home */
9866   g_object_ref (button);
9867   gtk_container_remove (GTK_CONTAINER (tree_view), button);
9868   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9869   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
9870   g_object_unref (button);
9871
9872   gtk_widget_get_allocation (button, &button_allocation);
9873   tree_view->priv->drag_column_x = button_allocation.x;
9874   allocation = button_allocation;
9875   allocation.x = 0;
9876   gtk_widget_size_allocate (button, &allocation);
9877   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9878
9879   tree_view->priv->drag_column = column;
9880   gdk_window_show (tree_view->priv->drag_window);
9881
9882   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9883   while (gtk_events_pending ())
9884     gtk_main_iteration ();
9885
9886   tree_view->priv->in_column_drag = TRUE;
9887
9888   gdk_device_grab (pointer,
9889                    tree_view->priv->drag_window,
9890                    GDK_OWNERSHIP_NONE,
9891                    FALSE,
9892                    GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9893                    NULL,
9894                    GDK_CURRENT_TIME);
9895   gdk_device_grab (keyboard,
9896                    tree_view->priv->drag_window,
9897                    GDK_OWNERSHIP_NONE,
9898                    FALSE,
9899                    GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
9900                    NULL,
9901                    GDK_CURRENT_TIME);
9902 }
9903
9904 static void
9905 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9906                                 GtkRBTree          *tree,
9907                                 GtkRBNode          *node)
9908 {
9909   GtkAllocation allocation;
9910   GdkRectangle rect;
9911
9912   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9913     return;
9914
9915   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9916   rect.x = 0;
9917   rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, allocation.width));
9918
9919   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9920   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9921
9922   gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9923 }
9924
9925 void
9926 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9927                                 GtkRBTree          *tree,
9928                                 GtkRBNode          *node,
9929                                 const GdkRectangle *clip_rect)
9930 {
9931   GtkAllocation allocation;
9932   GdkRectangle rect;
9933
9934   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9935     return;
9936
9937   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9938   rect.x = 0;
9939   rect.width = MAX (tree_view->priv->width, allocation.width);
9940
9941   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9942   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9943
9944   if (clip_rect)
9945     {
9946       GdkRectangle new_rect;
9947
9948       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9949
9950       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9951     }
9952   else
9953     {
9954       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9955     }
9956 }
9957
9958 static inline gint
9959 gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view)
9960 {
9961   if (tree_view->priv->headers_visible)
9962     return tree_view->priv->header_height;
9963   /* else */
9964   return 0;
9965 }
9966
9967 gint
9968 _gtk_tree_view_get_header_height (GtkTreeView *tree_view)
9969 {
9970   return tree_view->priv->header_height;
9971 }
9972
9973 void
9974 _gtk_tree_view_get_row_separator_func (GtkTreeView                 *tree_view,
9975                                        GtkTreeViewRowSeparatorFunc *func,
9976                                        gpointer                    *data)
9977 {
9978   *func = tree_view->priv->row_separator_func;
9979   *data = tree_view->priv->row_separator_data;
9980 }
9981
9982 GtkTreePath *
9983 _gtk_tree_view_get_anchor_path (GtkTreeView *tree_view)
9984 {
9985   if (tree_view->priv->anchor)
9986     return gtk_tree_row_reference_get_path (tree_view->priv->anchor);
9987
9988   return NULL;
9989 }
9990
9991 void
9992 _gtk_tree_view_set_anchor_path (GtkTreeView *tree_view,
9993                                 GtkTreePath *anchor_path)
9994 {
9995   if (tree_view->priv->anchor)
9996     {
9997       gtk_tree_row_reference_free (tree_view->priv->anchor);
9998       tree_view->priv->anchor = NULL;
9999     }
10000
10001   if (anchor_path && tree_view->priv->model)
10002     tree_view->priv->anchor =
10003       gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
10004                                         tree_view->priv->model, anchor_path);
10005 }
10006
10007 GtkRBTree *
10008 _gtk_tree_view_get_rbtree (GtkTreeView *tree_view)
10009 {
10010   return tree_view->priv->tree;
10011 }
10012
10013 gboolean
10014 _gtk_tree_view_get_cursor_node (GtkTreeView  *tree_view,
10015                                 GtkRBTree   **tree,
10016                                 GtkRBNode   **node)
10017 {
10018   GtkTreeViewPrivate *priv;
10019
10020   priv = tree_view->priv;
10021
10022   if (priv->cursor_node == NULL)
10023     return FALSE;
10024
10025   *tree = priv->cursor_tree;
10026   *node = priv->cursor_node;
10027
10028   return TRUE;
10029 }
10030
10031 GdkWindow *
10032 _gtk_tree_view_get_header_window (GtkTreeView *tree_view)
10033 {
10034   return tree_view->priv->header_window;
10035 }
10036
10037 GtkTreeViewColumn *
10038 _gtk_tree_view_get_focus_column (GtkTreeView *tree_view)
10039 {
10040   return tree_view->priv->focus_column;
10041 }
10042
10043 void
10044 _gtk_tree_view_set_focus_column (GtkTreeView       *tree_view,
10045                                  GtkTreeViewColumn *column)
10046 {
10047   GtkTreeViewColumn *old_column = tree_view->priv->focus_column;
10048
10049   if (old_column == column)
10050     return;
10051
10052   tree_view->priv->focus_column = column;
10053
10054   _gtk_tree_view_accessible_update_focus_column (tree_view,
10055                                                  old_column,
10056                                                  column);
10057 }
10058
10059
10060 static void
10061 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
10062                                GtkTreePath        *path,
10063                                const GdkRectangle *clip_rect)
10064 {
10065   GtkRBTree *tree = NULL;
10066   GtkRBNode *node = NULL;
10067
10068   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
10069
10070   if (tree)
10071     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
10072 }
10073
10074 /* x and y are the mouse position
10075  */
10076 static void
10077 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
10078                           cairo_t     *cr,
10079                           GtkRBTree   *tree,
10080                           GtkRBNode   *node)
10081 {
10082   GdkRectangle area;
10083   GtkStateFlags state = 0;
10084   GtkStyleContext *context;
10085   GtkWidget *widget;
10086   gint x_offset = 0;
10087   gint x2;
10088   gint vertical_separator;
10089   gint expander_size;
10090   GtkCellRendererState flags = 0;
10091
10092   widget = GTK_WIDGET (tree_view);
10093   context = gtk_widget_get_style_context (widget);
10094
10095   gtk_widget_style_get (widget,
10096                         "vertical-separator", &vertical_separator,
10097                         NULL);
10098   expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
10099
10100   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
10101     return;
10102
10103   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
10104
10105   area.x = x_offset;
10106   area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
10107                                                  vertical_separator);
10108   area.width = expander_size;
10109   area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
10110                                                     vertical_separator);
10111
10112   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
10113     flags |= GTK_CELL_RENDERER_SELECTED;
10114
10115   if (node == tree_view->priv->prelight_node &&
10116       tree_view->priv->arrow_prelit)
10117     flags |= GTK_CELL_RENDERER_PRELIT;
10118
10119   state = gtk_cell_renderer_get_state (NULL, widget, flags);
10120
10121   if (node->children != NULL)
10122     state |= GTK_STATE_FLAG_ACTIVE;
10123   else
10124     state &= ~(GTK_STATE_FLAG_ACTIVE);
10125
10126   gtk_style_context_save (context);
10127
10128   gtk_style_context_set_state (context, state);
10129   gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
10130
10131   gtk_style_context_push_animatable_region (context, node);
10132
10133   gtk_render_expander (context, cr,
10134                        area.x, area.y,
10135                        area.width, area.height);
10136
10137   gtk_style_context_pop_animatable_region (context);
10138   gtk_style_context_restore (context);
10139 }
10140
10141 static void
10142 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
10143
10144 {
10145   GtkTreePath *cursor_path;
10146
10147   if ((tree_view->priv->tree == NULL) ||
10148       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
10149     return;
10150
10151   cursor_path = NULL;
10152   if (tree_view->priv->cursor_node)
10153     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10154                                                   tree_view->priv->cursor_node);
10155
10156   if (cursor_path == NULL)
10157     {
10158       /* Consult the selection before defaulting to the
10159        * first focusable element
10160        */
10161       GList *selected_rows;
10162       GtkTreeModel *model;
10163       GtkTreeSelection *selection;
10164
10165       selection = gtk_tree_view_get_selection (tree_view);
10166       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
10167
10168       if (selected_rows)
10169         {
10170           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
10171           g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free);
10172         }
10173       else
10174         {
10175           cursor_path = gtk_tree_path_new_first ();
10176           search_first_focusable_path (tree_view, &cursor_path,
10177                                        TRUE, NULL, NULL);
10178         }
10179
10180       if (cursor_path)
10181         {
10182           if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
10183             gtk_tree_view_real_set_cursor (tree_view, cursor_path, 0);
10184           else
10185             gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10186         }
10187     }
10188
10189   if (cursor_path)
10190     {
10191       tree_view->priv->draw_keyfocus = TRUE;
10192
10193       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10194       gtk_tree_path_free (cursor_path);
10195
10196       if (tree_view->priv->focus_column == NULL)
10197         {
10198           GList *list;
10199           for (list = tree_view->priv->columns; list; list = list->next)
10200             {
10201               if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
10202                 {
10203                   GtkCellArea *cell_area;
10204
10205                   _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
10206
10207                   /* This happens when the treeview initially grabs focus and there
10208                    * is no column in focus, here we explicitly focus into the first cell */
10209                   cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10210                   if (!gtk_cell_area_get_focus_cell (cell_area))
10211                     {
10212                       gboolean rtl;
10213
10214                       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10215                       gtk_cell_area_focus (cell_area,
10216                                            rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
10217                     }
10218
10219                   break;
10220                 }
10221             }
10222         }
10223     }
10224 }
10225
10226 static void
10227 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
10228                                    gint         count)
10229 {
10230   gint selection_count;
10231   GtkRBTree *new_cursor_tree = NULL;
10232   GtkRBNode *new_cursor_node = NULL;
10233   GtkTreePath *cursor_path = NULL;
10234   gboolean grab_focus = TRUE;
10235   gboolean selectable;
10236   GtkDirectionType direction;
10237   GtkCellArea *cell_area = NULL;
10238   GtkCellRenderer *last_focus_cell = NULL;
10239   GtkTreeIter iter;
10240
10241   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10242     return;
10243
10244   if (tree_view->priv->cursor_node == NULL)
10245     return;
10246
10247   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10248                                                 tree_view->priv->cursor_node);
10249
10250   direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
10251
10252   if (tree_view->priv->focus_column)
10253     cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10254
10255   /* If focus stays in the area for this row, then just return for this round */
10256   if (cell_area && (count == -1 || count == 1) &&
10257       gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path))
10258     {
10259       gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
10260                                                tree_view->priv->model,
10261                                                &iter,
10262                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10263                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10264
10265       /* Save the last cell that had focus, if we hit the end of the view we'll give
10266        * focus back to it. */
10267       last_focus_cell = gtk_cell_area_get_focus_cell (cell_area);
10268
10269       /* If focus stays in the area, no need to change the cursor row */
10270       if (gtk_cell_area_focus (cell_area, direction))
10271         return;
10272     }
10273
10274   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
10275   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
10276                                                       tree_view->priv->cursor_node,
10277                                                       cursor_path);
10278
10279   if (selection_count == 0
10280       && gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE
10281       && !tree_view->priv->modify_selection_pressed
10282       && selectable)
10283     {
10284       /* Don't move the cursor, but just select the current node */
10285       new_cursor_tree = tree_view->priv->cursor_tree;
10286       new_cursor_node = tree_view->priv->cursor_node;
10287     }
10288   else
10289     {
10290       if (count == -1)
10291         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10292                                &new_cursor_tree, &new_cursor_node);
10293       else
10294         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10295                                &new_cursor_tree, &new_cursor_node);
10296     }
10297
10298   gtk_tree_path_free (cursor_path);
10299
10300   if (new_cursor_node)
10301     {
10302       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10303
10304       search_first_focusable_path (tree_view, &cursor_path,
10305                                    (count != -1),
10306                                    &new_cursor_tree,
10307                                    &new_cursor_node);
10308
10309       if (cursor_path)
10310         gtk_tree_path_free (cursor_path);
10311     }
10312
10313   /*
10314    * If the list has only one item and multi-selection is set then select
10315    * the row (if not yet selected).
10316    */
10317   if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE &&
10318       new_cursor_node == NULL)
10319     {
10320       if (count == -1)
10321         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10322                                &new_cursor_tree, &new_cursor_node);
10323       else
10324         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10325                                &new_cursor_tree, &new_cursor_node);
10326
10327       if (new_cursor_node == NULL
10328           && !GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
10329         {
10330           new_cursor_node = tree_view->priv->cursor_node;
10331           new_cursor_tree = tree_view->priv->cursor_tree;
10332         }
10333       else
10334         {
10335           new_cursor_tree = NULL;
10336           new_cursor_node = NULL;
10337         }
10338     }
10339
10340   if (new_cursor_node)
10341     {
10342       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10343       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10344       gtk_tree_path_free (cursor_path);
10345
10346       /* Give focus to the area in the new row */
10347       if (cell_area)
10348         gtk_cell_area_focus (cell_area, direction);
10349     }
10350   else
10351     {
10352       gtk_tree_view_clamp_node_visible (tree_view,
10353                                         tree_view->priv->cursor_tree,
10354                                         tree_view->priv->cursor_node);
10355
10356       if (!tree_view->priv->extend_selection_pressed)
10357         {
10358           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
10359                                           count < 0 ?
10360                                           GTK_DIR_UP : GTK_DIR_DOWN))
10361             {
10362               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10363
10364               if (toplevel)
10365                 gtk_widget_child_focus (toplevel,
10366                                         count < 0 ?
10367                                         GTK_DIR_TAB_BACKWARD :
10368                                         GTK_DIR_TAB_FORWARD);
10369
10370               grab_focus = FALSE;
10371             }
10372         }
10373       else
10374         {
10375           gtk_widget_error_bell (GTK_WIDGET (tree_view));
10376         }
10377
10378       if (cell_area)
10379         gtk_cell_area_set_focus_cell (cell_area, last_focus_cell);
10380     }
10381
10382   if (grab_focus)
10383     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10384 }
10385
10386 static void
10387 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
10388                                         gint         count)
10389 {
10390   GtkTreePath *old_cursor_path = NULL;
10391   GtkTreePath *cursor_path = NULL;
10392   GtkRBTree *start_cursor_tree = NULL;
10393   GtkRBNode *start_cursor_node = NULL;
10394   GtkRBTree *cursor_tree;
10395   GtkRBNode *cursor_node;
10396   gint y;
10397   gint window_y;
10398   gint vertical_separator;
10399
10400   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10401     return;
10402
10403   if (tree_view->priv->cursor_node == NULL)
10404     return;
10405
10406   old_cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10407                                                     tree_view->priv->cursor_node);
10408
10409   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
10410
10411   y = _gtk_rbtree_node_find_offset (tree_view->priv->cursor_tree, tree_view->priv->cursor_node);
10412   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
10413   y += tree_view->priv->cursor_offset;
10414   y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
10415   y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment),  (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
10416
10417   if (y >= tree_view->priv->height)
10418     y = tree_view->priv->height - 1;
10419
10420   tree_view->priv->cursor_offset =
10421     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
10422                              &cursor_tree, &cursor_node);
10423
10424   if (cursor_tree == NULL)
10425     {
10426       /* FIXME: we lost the cursor.  Should we try to get one? */
10427       gtk_tree_path_free (old_cursor_path);
10428       return;
10429     }
10430
10431   if (tree_view->priv->cursor_offset
10432       > gtk_tree_view_get_row_height (tree_view, cursor_node))
10433     {
10434       _gtk_rbtree_next_full (cursor_tree, cursor_node,
10435                              &cursor_tree, &cursor_node);
10436       tree_view->priv->cursor_offset -= gtk_tree_view_get_row_height (tree_view, cursor_node);
10437     }
10438
10439   y -= tree_view->priv->cursor_offset;
10440   cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10441
10442   start_cursor_tree = cursor_tree;
10443   start_cursor_node = cursor_node;
10444
10445   if (! search_first_focusable_path (tree_view, &cursor_path,
10446                                      (count != -1),
10447                                      &cursor_tree, &cursor_node))
10448     {
10449       /* It looks like we reached the end of the view without finding
10450        * a focusable row.  We will step backwards to find the last
10451        * focusable row.
10452        */
10453       cursor_tree = start_cursor_tree;
10454       cursor_node = start_cursor_node;
10455       cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10456
10457       search_first_focusable_path (tree_view, &cursor_path,
10458                                    (count == -1),
10459                                    &cursor_tree, &cursor_node);
10460     }
10461
10462   if (!cursor_path)
10463     goto cleanup;
10464
10465   /* update y */
10466   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10467
10468   gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10469
10470   y -= window_y;
10471   gtk_tree_view_scroll_to_point (tree_view, -1, y);
10472   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10473   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10474
10475   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
10476     gtk_widget_error_bell (GTK_WIDGET (tree_view));
10477
10478   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10479
10480 cleanup:
10481   gtk_tree_path_free (old_cursor_path);
10482   gtk_tree_path_free (cursor_path);
10483 }
10484
10485 static void
10486 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
10487                                       gint         count)
10488 {
10489   GtkTreePath *cursor_path = NULL;
10490   GtkTreeViewColumn *column;
10491   GtkTreeIter iter;
10492   GList *list;
10493   gboolean found_column = FALSE;
10494   gboolean rtl;
10495   GtkDirectionType direction;
10496   GtkCellArea     *cell_area;
10497   GtkCellRenderer *last_focus_cell = NULL;
10498   GtkCellArea     *last_focus_area = NULL;
10499
10500   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10501
10502   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10503     return;
10504
10505   if (tree_view->priv->cursor_node == NULL)
10506     return;
10507
10508   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10509                                                 tree_view->priv->cursor_node);
10510
10511   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
10512     {
10513       gtk_tree_path_free (cursor_path);
10514       return;
10515     }
10516   gtk_tree_path_free (cursor_path);
10517
10518   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
10519   if (tree_view->priv->focus_column)
10520     {
10521       /* Save the cell/area we are moving focus from, if moving the cursor
10522        * by one step hits the end we'll set focus back here */
10523       last_focus_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10524       last_focus_cell = gtk_cell_area_get_focus_cell (last_focus_area);
10525
10526       for (; list; list = (rtl ? list->prev : list->next))
10527         {
10528           if (list->data == tree_view->priv->focus_column)
10529             break;
10530         }
10531     }
10532
10533   direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
10534
10535   while (list)
10536     {
10537       column = list->data;
10538       if (gtk_tree_view_column_get_visible (column) == FALSE)
10539         goto loop_end;
10540
10541       gtk_tree_view_column_cell_set_cell_data (column,
10542                                                tree_view->priv->model,
10543                                                &iter,
10544                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10545                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10546
10547       cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
10548       if (gtk_cell_area_focus (cell_area, direction))
10549         {
10550           _gtk_tree_view_set_focus_column (tree_view, column);
10551           found_column = TRUE;
10552           break;
10553         }
10554
10555     loop_end:
10556       if (count == 1)
10557         list = rtl ? list->prev : list->next;
10558       else
10559         list = rtl ? list->next : list->prev;
10560     }
10561
10562   if (found_column)
10563     {
10564       if (!gtk_tree_view_has_can_focus_cell (tree_view))
10565         _gtk_tree_view_queue_draw_node (tree_view,
10566                                         tree_view->priv->cursor_tree,
10567                                         tree_view->priv->cursor_node,
10568                                         NULL);
10569       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
10570       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10571     }
10572   else
10573     {
10574       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10575
10576       if (last_focus_area)
10577         gtk_cell_area_set_focus_cell (last_focus_area, last_focus_cell);
10578     }
10579
10580   gtk_tree_view_clamp_column_visible (tree_view,
10581                                       tree_view->priv->focus_column, TRUE);
10582 }
10583
10584 static void
10585 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
10586                                      gint         count)
10587 {
10588   GtkRBTree *cursor_tree;
10589   GtkRBNode *cursor_node;
10590   GtkTreePath *path;
10591   GtkTreePath *old_path;
10592
10593   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10594     return;
10595
10596   g_return_if_fail (tree_view->priv->tree != NULL);
10597
10598   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
10599
10600   cursor_tree = tree_view->priv->tree;
10601
10602   if (count == -1)
10603     {
10604       cursor_node = _gtk_rbtree_first (cursor_tree);
10605
10606       /* Now go forward to find the first focusable row. */
10607       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10608       search_first_focusable_path (tree_view, &path,
10609                                    TRUE, &cursor_tree, &cursor_node);
10610     }
10611   else
10612     {
10613       cursor_node = cursor_tree->root;
10614
10615       do
10616         {
10617           while (cursor_node && !_gtk_rbtree_is_nil (cursor_node->right))
10618             cursor_node = cursor_node->right;
10619           if (cursor_node->children == NULL)
10620             break;
10621
10622           cursor_tree = cursor_node->children;
10623           cursor_node = cursor_tree->root;
10624         }
10625       while (1);
10626
10627       /* Now go backwards to find last focusable row. */
10628       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10629       search_first_focusable_path (tree_view, &path,
10630                                    FALSE, &cursor_tree, &cursor_node);
10631     }
10632
10633   if (!path)
10634     goto cleanup;
10635
10636   if (gtk_tree_path_compare (old_path, path))
10637     {
10638       gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
10639       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10640     }
10641   else
10642     {
10643       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10644     }
10645
10646 cleanup:
10647   gtk_tree_path_free (old_path);
10648   gtk_tree_path_free (path);
10649 }
10650
10651 static gboolean
10652 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10653 {
10654   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10655     return FALSE;
10656
10657   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10658     return FALSE;
10659
10660   gtk_tree_selection_select_all (tree_view->priv->selection);
10661
10662   return TRUE;
10663 }
10664
10665 static gboolean
10666 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
10667 {
10668   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10669     return FALSE;
10670
10671   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10672     return FALSE;
10673
10674   gtk_tree_selection_unselect_all (tree_view->priv->selection);
10675
10676   return TRUE;
10677 }
10678
10679 static gboolean
10680 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10681                                       gboolean     start_editing)
10682 {
10683   GtkRBTree *new_tree = NULL;
10684   GtkRBNode *new_node = NULL;
10685   GtkRBTree *cursor_tree = NULL;
10686   GtkRBNode *cursor_node = NULL;
10687   GtkTreePath *cursor_path = NULL;
10688   GtkTreeSelectMode mode = 0;
10689
10690   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10691     return FALSE;
10692
10693   if (tree_view->priv->cursor_node == NULL)
10694     return FALSE;
10695
10696   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10697                                                 tree_view->priv->cursor_node);
10698
10699   _gtk_tree_view_find_node (tree_view, cursor_path,
10700                             &cursor_tree, &cursor_node);
10701
10702   if (cursor_tree == NULL)
10703     {
10704       gtk_tree_path_free (cursor_path);
10705       return FALSE;
10706     }
10707
10708   if (!tree_view->priv->extend_selection_pressed && start_editing &&
10709       tree_view->priv->focus_column)
10710     {
10711       if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE))
10712         {
10713           gtk_tree_path_free (cursor_path);
10714           return TRUE;
10715         }
10716     }
10717
10718   if (tree_view->priv->modify_selection_pressed)
10719     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10720   if (tree_view->priv->extend_selection_pressed)
10721     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10722
10723   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10724                                             cursor_node,
10725                                             cursor_tree,
10726                                             cursor_path,
10727                                             mode,
10728                                             FALSE);
10729
10730   /* We bail out if the original (tree, node) don't exist anymore after
10731    * handling the selection-changed callback.  We do return TRUE because
10732    * the key press has been handled at this point.
10733    */
10734   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10735
10736   if (cursor_tree != new_tree || cursor_node != new_node)
10737     return FALSE;
10738
10739   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10740
10741   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10742   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10743
10744   if (!tree_view->priv->extend_selection_pressed)
10745     gtk_tree_view_row_activated (tree_view, cursor_path,
10746                                  tree_view->priv->focus_column);
10747
10748   gtk_tree_path_free (cursor_path);
10749
10750   return TRUE;
10751 }
10752
10753 static gboolean
10754 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10755 {
10756   GtkRBTree *new_tree = NULL;
10757   GtkRBNode *new_node = NULL;
10758   GtkTreePath *cursor_path = NULL;
10759
10760   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10761     return FALSE;
10762
10763   if (tree_view->priv->cursor_node == NULL)
10764     return FALSE;
10765
10766   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10767                                                 tree_view->priv->cursor_node);
10768
10769   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10770                                             tree_view->priv->cursor_node,
10771                                             tree_view->priv->cursor_tree,
10772                                             cursor_path,
10773                                             GTK_TREE_SELECT_MODE_TOGGLE,
10774                                             FALSE);
10775
10776   /* We bail out if the original (tree, node) don't exist anymore after
10777    * handling the selection-changed callback.  We do return TRUE because
10778    * the key press has been handled at this point.
10779    */
10780   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10781
10782   if (tree_view->priv->cursor_node != new_node)
10783     return FALSE;
10784
10785   gtk_tree_view_clamp_node_visible (tree_view,
10786                                     tree_view->priv->cursor_tree,
10787                                     tree_view->priv->cursor_node);
10788
10789   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10790   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10791   gtk_tree_path_free (cursor_path);
10792
10793   return TRUE;
10794 }
10795
10796 static gboolean
10797 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10798                                                gboolean     logical,
10799                                                gboolean     expand,
10800                                                gboolean     open_all)
10801 {
10802   GtkTreePath *cursor_path = NULL;
10803
10804   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10805     return FALSE;
10806
10807   if (tree_view->priv->cursor_node == NULL)
10808     return FALSE;
10809
10810   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10811                                                 tree_view->priv->cursor_node);
10812
10813   /* Don't handle the event if we aren't an expander */
10814   if (!GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT))
10815     return FALSE;
10816
10817   if (!logical
10818       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10819     expand = !expand;
10820
10821   if (expand)
10822     gtk_tree_view_real_expand_row (tree_view,
10823                                    cursor_path,
10824                                    tree_view->priv->cursor_tree,
10825                                    tree_view->priv->cursor_node,
10826                                    open_all,
10827                                    TRUE);
10828   else
10829     gtk_tree_view_real_collapse_row (tree_view,
10830                                      cursor_path,
10831                                      tree_view->priv->cursor_tree,
10832                                      tree_view->priv->cursor_node,
10833                                      TRUE);
10834
10835   gtk_tree_path_free (cursor_path);
10836
10837   return TRUE;
10838 }
10839
10840 static gboolean
10841 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10842 {
10843   GtkTreePath *cursor_path = NULL;
10844   GdkModifierType state;
10845
10846   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10847     goto out;
10848
10849   if (tree_view->priv->cursor_node == NULL)
10850     goto out;
10851
10852   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10853                                                 tree_view->priv->cursor_node);
10854
10855   if (tree_view->priv->cursor_tree->parent_node)
10856     {
10857       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10858
10859       gtk_tree_path_up (cursor_path);
10860
10861       if (gtk_get_current_event_state (&state))
10862         {
10863           GdkModifierType modify_mod_mask;
10864
10865           modify_mod_mask =
10866             gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
10867                                           GDK_MODIFIER_INTENT_MODIFY_SELECTION);
10868
10869           if ((state & modify_mod_mask) == modify_mod_mask)
10870             tree_view->priv->modify_selection_pressed = TRUE;
10871         }
10872
10873       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10874       gtk_tree_path_free (cursor_path);
10875
10876       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10877
10878       tree_view->priv->modify_selection_pressed = FALSE;
10879
10880       return TRUE;
10881     }
10882
10883  out:
10884
10885   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10886   return FALSE;
10887 }
10888
10889 static gboolean
10890 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10891 {
10892   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
10893   tree_view->priv->typeselect_flush_timeout = 0;
10894
10895   return FALSE;
10896 }
10897
10898 /* Cut and paste from gtkwindow.c */
10899 static void
10900 send_focus_change (GtkWidget *widget,
10901                    GdkDevice *device,
10902                    gboolean   in)
10903 {
10904   GdkDeviceManager *device_manager;
10905   GList *devices, *d;
10906
10907   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
10908   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
10909   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
10910   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
10911
10912   for (d = devices; d; d = d->next)
10913     {
10914       GdkDevice *dev = d->data;
10915       GdkEvent *fevent;
10916       GdkWindow *window;
10917
10918       if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
10919         continue;
10920
10921       window = gtk_widget_get_window (widget);
10922
10923       /* Skip non-master keyboards that haven't
10924        * selected for events from this window
10925        */
10926       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
10927           !gdk_window_get_device_events (window, dev))
10928         continue;
10929
10930       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10931
10932       fevent->focus_change.type = GDK_FOCUS_CHANGE;
10933       fevent->focus_change.window = g_object_ref (window);
10934       fevent->focus_change.in = in;
10935       gdk_event_set_device (fevent, device);
10936
10937       gtk_widget_send_focus_change (widget, fevent);
10938
10939       gdk_event_free (fevent);
10940     }
10941
10942   g_list_free (devices);
10943 }
10944
10945 static void
10946 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10947 {
10948   GtkWidget *frame, *vbox, *toplevel;
10949   GdkScreen *screen;
10950
10951   if (tree_view->priv->search_custom_entry_set)
10952     return;
10953
10954   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10955   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10956
10957    if (tree_view->priv->search_window != NULL)
10958      {
10959        if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10960          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10961                                       GTK_WINDOW (tree_view->priv->search_window));
10962        else if (gtk_window_has_group (GTK_WINDOW (tree_view->priv->search_window)))
10963          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
10964                                          GTK_WINDOW (tree_view->priv->search_window));
10965
10966        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10967
10968        return;
10969      }
10970
10971   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10972   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10973
10974   if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10975     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10976                                  GTK_WINDOW (tree_view->priv->search_window));
10977
10978   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10979                             GDK_WINDOW_TYPE_HINT_UTILITY);
10980   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10981   g_signal_connect (tree_view->priv->search_window, "delete-event",
10982                     G_CALLBACK (gtk_tree_view_search_delete_event),
10983                     tree_view);
10984   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10985                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10986                     tree_view);
10987   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10988                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10989                     tree_view);
10990   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10991                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10992                     tree_view);
10993
10994   frame = gtk_frame_new (NULL);
10995   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10996   gtk_widget_show (frame);
10997   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10998
10999   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
11000   gtk_widget_show (vbox);
11001   gtk_container_add (GTK_CONTAINER (frame), vbox);
11002   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
11003
11004   /* add entry */
11005   tree_view->priv->search_entry = gtk_entry_new ();
11006   gtk_widget_show (tree_view->priv->search_entry);
11007   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
11008                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
11009                     tree_view);
11010   g_signal_connect (tree_view->priv->search_entry,
11011                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
11012                     tree_view);
11013
11014   g_signal_connect (_gtk_entry_get_im_context (GTK_ENTRY (tree_view->priv->search_entry)),
11015                     "preedit-changed",
11016                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
11017                     tree_view);
11018
11019   gtk_container_add (GTK_CONTAINER (vbox),
11020                      tree_view->priv->search_entry);
11021
11022   gtk_widget_realize (tree_view->priv->search_entry);
11023 }
11024
11025 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
11026  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
11027  */
11028 static gboolean
11029 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
11030                                              GdkDevice   *device,
11031                                              gboolean     keybinding)
11032 {
11033   /* We only start interactive search if we have focus or the columns
11034    * have focus.  If one of our children have focus, we don't want to
11035    * start the search.
11036    */
11037   GList *list;
11038   gboolean found_focus = FALSE;
11039   GtkWidgetClass *entry_parent_class;
11040
11041   if (!tree_view->priv->enable_search && !keybinding)
11042     return FALSE;
11043
11044   if (tree_view->priv->search_custom_entry_set)
11045     return FALSE;
11046
11047   if (tree_view->priv->search_window != NULL &&
11048       gtk_widget_get_visible (tree_view->priv->search_window))
11049     return TRUE;
11050
11051   for (list = tree_view->priv->columns; list; list = list->next)
11052     {
11053       GtkTreeViewColumn *column;
11054       GtkWidget         *button;
11055
11056       column = list->data;
11057       if (!gtk_tree_view_column_get_visible (column))
11058         continue;
11059
11060       button = gtk_tree_view_column_get_button (column);
11061       if (gtk_widget_has_focus (button))
11062         {
11063           found_focus = TRUE;
11064           break;
11065         }
11066     }
11067
11068   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
11069     found_focus = TRUE;
11070
11071   if (!found_focus)
11072     return FALSE;
11073
11074   if (tree_view->priv->search_column < 0)
11075     return FALSE;
11076
11077   gtk_tree_view_ensure_interactive_directory (tree_view);
11078
11079   if (keybinding)
11080     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
11081
11082   /* done, show it */
11083   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
11084   gtk_widget_show (tree_view->priv->search_window);
11085   if (tree_view->priv->search_entry_changed_id == 0)
11086     {
11087       tree_view->priv->search_entry_changed_id =
11088         g_signal_connect (tree_view->priv->search_entry, "changed",
11089                           G_CALLBACK (gtk_tree_view_search_init),
11090                           tree_view);
11091     }
11092
11093   tree_view->priv->typeselect_flush_timeout =
11094     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
11095                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
11096                    tree_view);
11097
11098   /* Grab focus will select all the text.  We don't want that to happen, so we
11099    * call the parent instance and bypass the selection change.  This is probably
11100    * really non-kosher. */
11101   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
11102   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
11103
11104   /* send focus-in event */
11105   send_focus_change (tree_view->priv->search_entry, device, TRUE);
11106
11107   /* search first matching iter */
11108   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
11109
11110   return TRUE;
11111 }
11112
11113 static gboolean
11114 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
11115 {
11116   return gtk_tree_view_real_start_interactive_search (tree_view,
11117                                                       gtk_get_current_event_device (),
11118                                                       TRUE);
11119 }
11120
11121 /* this function returns the new width of the column being resized given
11122  * the column and x position of the cursor; the x cursor position is passed
11123  * in as a pointer and automagicly corrected if it's beyond min/max limits
11124  */
11125 static gint
11126 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
11127                                 gint       i,
11128                                 gint      *x)
11129 {
11130   GtkAllocation allocation;
11131   GtkTreeViewColumn *column;
11132   GtkRequisition button_req;
11133   gint max_width, min_width;
11134   gint width;
11135   gboolean rtl;
11136
11137   /* first translate the x position from widget->window
11138    * to clist->clist_window
11139    */
11140   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
11141   column = g_list_nth (tree_view->priv->columns, i)->data;
11142   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
11143   width = rtl ? (allocation.x + allocation.width - *x) : (*x - allocation.x);
11144
11145   /* Clamp down the value */
11146   min_width = gtk_tree_view_column_get_min_width (column);
11147   if (min_width == -1)
11148     {
11149       gtk_widget_get_preferred_size (gtk_tree_view_column_get_button (column), &button_req, NULL);
11150       width = MAX (button_req.width, width);
11151     }
11152   else
11153     width = MAX (min_width, width);
11154
11155   max_width = gtk_tree_view_column_get_max_width (column);
11156   if (max_width != -1)
11157     width = MIN (width, max_width);
11158
11159   *x = rtl ? (allocation.x + allocation.width - width) : (allocation.x + width);
11160
11161   return width;
11162 }
11163
11164
11165 /* FIXME this adjust_allocation is a big cut-and-paste from
11166  * GtkCList, needs to be some "official" way to do this
11167  * factored out.
11168  */
11169 typedef struct
11170 {
11171   GdkWindow *window;
11172   int dx;
11173   int dy;
11174 } ScrollData;
11175
11176 /* The window to which widget->window is relative */
11177 #define ALLOCATION_WINDOW(widget)               \
11178    (!gtk_widget_get_has_window (widget) ?                   \
11179     gtk_widget_get_window (widget) :                        \
11180     gdk_window_get_parent (gtk_widget_get_window (widget)))
11181
11182 static void
11183 adjust_allocation_recurse (GtkWidget *widget,
11184                            gpointer   data)
11185 {
11186   GtkAllocation allocation;
11187   ScrollData *scroll_data = data;
11188
11189   /* Need to really size allocate instead of just poking
11190    * into widget->allocation if the widget is not realized.
11191    * FIXME someone figure out why this was.
11192    */
11193   gtk_widget_get_allocation (widget, &allocation);
11194   if (!gtk_widget_get_realized (widget))
11195     {
11196       if (gtk_widget_get_visible (widget))
11197         {
11198           GdkRectangle tmp_rectangle = allocation;
11199           tmp_rectangle.x += scroll_data->dx;
11200           tmp_rectangle.y += scroll_data->dy;
11201
11202           gtk_widget_size_allocate (widget, &tmp_rectangle);
11203         }
11204     }
11205   else
11206     {
11207       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
11208         {
11209           allocation.x += scroll_data->dx;
11210           allocation.y += scroll_data->dy;
11211           gtk_widget_set_allocation (widget, &allocation);
11212
11213           if (GTK_IS_CONTAINER (widget))
11214             gtk_container_forall (GTK_CONTAINER (widget),
11215                                   adjust_allocation_recurse,
11216                                   data);
11217         }
11218     }
11219 }
11220
11221 static void
11222 adjust_allocation (GtkWidget *widget,
11223                    int        dx,
11224                    int        dy)
11225 {
11226   ScrollData scroll_data;
11227
11228   if (gtk_widget_get_realized (widget))
11229     scroll_data.window = ALLOCATION_WINDOW (widget);
11230   else
11231     scroll_data.window = NULL;
11232
11233   scroll_data.dx = dx;
11234   scroll_data.dy = dy;
11235
11236   adjust_allocation_recurse (widget, &scroll_data);
11237 }
11238
11239 /* Callbacks */
11240 static void
11241 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
11242                                   GtkTreeView   *tree_view)
11243 {
11244   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11245     {
11246       GtkStyleContext *context;
11247       gint dy;
11248
11249       gdk_window_move (tree_view->priv->bin_window,
11250                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11251                        gtk_tree_view_get_effective_header_height (tree_view));
11252       gdk_window_move (tree_view->priv->header_window,
11253                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11254                        0);
11255       dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11256       if (dy)
11257         {
11258           update_prelight (tree_view,
11259                            tree_view->priv->event_last_x,
11260                            tree_view->priv->event_last_y - dy);
11261
11262           if (tree_view->priv->edited_column)
11263             {
11264               GList *list;
11265               GtkTreeViewChild *child = NULL;
11266               GtkCellEditable *edit_widget;
11267               GtkCellArea *area;
11268
11269               area        = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column));
11270               edit_widget = gtk_cell_area_get_edit_widget (area);
11271               if (GTK_IS_WIDGET (edit_widget))
11272                 {
11273                   adjust_allocation (GTK_WIDGET (edit_widget), 0, dy);
11274
11275                   for (list = tree_view->priv->children; list; list = list->next)
11276                     {
11277                       child = (GtkTreeViewChild *)list->data;
11278                       if (child->widget == GTK_WIDGET (edit_widget))
11279                         {
11280                           child->y += dy;
11281                           break;
11282                         }
11283                     }
11284                 }
11285             }
11286         }
11287       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
11288
11289       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
11290       gtk_style_context_scroll_animations (context, tree_view->priv->bin_window, 0, dy);
11291
11292       if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
11293         {
11294           /* update our dy and top_row */
11295           tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11296
11297           if (!tree_view->priv->in_top_row_to_dy)
11298             gtk_tree_view_dy_to_top_row (tree_view);
11299         }
11300
11301       gdk_window_process_updates (tree_view->priv->header_window, TRUE);
11302       gtk_tree_view_bin_process_updates (tree_view);
11303     }
11304 }
11305
11306 \f
11307
11308 /* Public methods
11309  */
11310
11311 /**
11312  * gtk_tree_view_new:
11313  *
11314  * Creates a new #GtkTreeView widget.
11315  *
11316  * Return value: A newly created #GtkTreeView widget.
11317  **/
11318 GtkWidget *
11319 gtk_tree_view_new (void)
11320 {
11321   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
11322 }
11323
11324 /**
11325  * gtk_tree_view_new_with_model:
11326  * @model: the model.
11327  *
11328  * Creates a new #GtkTreeView widget with the model initialized to @model.
11329  *
11330  * Return value: A newly created #GtkTreeView widget.
11331  **/
11332 GtkWidget *
11333 gtk_tree_view_new_with_model (GtkTreeModel *model)
11334 {
11335   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
11336 }
11337
11338 /* Public Accessors
11339  */
11340
11341 /**
11342  * gtk_tree_view_get_model:
11343  * @tree_view: a #GtkTreeView
11344  *
11345  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
11346  * model is unset.
11347  *
11348  * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
11349  **/
11350 GtkTreeModel *
11351 gtk_tree_view_get_model (GtkTreeView *tree_view)
11352 {
11353   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11354
11355   return tree_view->priv->model;
11356 }
11357
11358 /**
11359  * gtk_tree_view_set_model:
11360  * @tree_view: A #GtkTreeNode.
11361  * @model: (allow-none): The model.
11362  *
11363  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
11364  * set, it will remove it before setting the new model.  If @model is %NULL,
11365  * then it will unset the old model.
11366  **/
11367 void
11368 gtk_tree_view_set_model (GtkTreeView  *tree_view,
11369                          GtkTreeModel *model)
11370 {
11371   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11372   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
11373
11374   if (model == tree_view->priv->model)
11375     return;
11376
11377   if (tree_view->priv->scroll_to_path)
11378     {
11379       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11380       tree_view->priv->scroll_to_path = NULL;
11381     }
11382
11383   if (tree_view->priv->rubber_band_status)
11384     gtk_tree_view_stop_rubber_band (tree_view);
11385
11386   if (tree_view->priv->model)
11387     {
11388       GList *tmplist = tree_view->priv->columns;
11389       GtkStyleContext *context;
11390
11391       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
11392       gtk_tree_view_stop_editing (tree_view, TRUE);
11393
11394       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
11395       gtk_style_context_cancel_animations (context, NULL);
11396
11397       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11398                                             gtk_tree_view_row_changed,
11399                                             tree_view);
11400       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11401                                             gtk_tree_view_row_inserted,
11402                                             tree_view);
11403       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11404                                             gtk_tree_view_row_has_child_toggled,
11405                                             tree_view);
11406       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11407                                             gtk_tree_view_row_deleted,
11408                                             tree_view);
11409       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11410                                             gtk_tree_view_rows_reordered,
11411                                             tree_view);
11412
11413       for (; tmplist; tmplist = tmplist->next)
11414         _gtk_tree_view_column_unset_model (tmplist->data,
11415                                            tree_view->priv->model);
11416
11417       if (tree_view->priv->tree)
11418         gtk_tree_view_free_rbtree (tree_view);
11419
11420       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
11421       tree_view->priv->drag_dest_row = NULL;
11422       gtk_tree_row_reference_free (tree_view->priv->anchor);
11423       tree_view->priv->anchor = NULL;
11424       gtk_tree_row_reference_free (tree_view->priv->top_row);
11425       tree_view->priv->top_row = NULL;
11426       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11427       tree_view->priv->scroll_to_path = NULL;
11428
11429       tree_view->priv->scroll_to_column = NULL;
11430
11431       g_object_unref (tree_view->priv->model);
11432
11433       tree_view->priv->search_column = -1;
11434       tree_view->priv->fixed_height_check = 0;
11435       tree_view->priv->fixed_height = -1;
11436       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
11437       tree_view->priv->last_button_x = -1;
11438       tree_view->priv->last_button_y = -1;
11439     }
11440
11441   tree_view->priv->model = model;
11442
11443   if (tree_view->priv->model)
11444     {
11445       gint i;
11446       GtkTreePath *path;
11447       GtkTreeIter iter;
11448       GtkTreeModelFlags flags;
11449
11450       if (tree_view->priv->search_column == -1)
11451         {
11452           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
11453             {
11454               GType type = gtk_tree_model_get_column_type (model, i);
11455
11456               if (g_value_type_transformable (type, G_TYPE_STRING))
11457                 {
11458                   tree_view->priv->search_column = i;
11459                   break;
11460                 }
11461             }
11462         }
11463
11464       g_object_ref (tree_view->priv->model);
11465       g_signal_connect (tree_view->priv->model,
11466                         "row-changed",
11467                         G_CALLBACK (gtk_tree_view_row_changed),
11468                         tree_view);
11469       g_signal_connect (tree_view->priv->model,
11470                         "row-inserted",
11471                         G_CALLBACK (gtk_tree_view_row_inserted),
11472                         tree_view);
11473       g_signal_connect (tree_view->priv->model,
11474                         "row-has-child-toggled",
11475                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
11476                         tree_view);
11477       g_signal_connect (tree_view->priv->model,
11478                         "row-deleted",
11479                         G_CALLBACK (gtk_tree_view_row_deleted),
11480                         tree_view);
11481       g_signal_connect (tree_view->priv->model,
11482                         "rows-reordered",
11483                         G_CALLBACK (gtk_tree_view_rows_reordered),
11484                         tree_view);
11485
11486       flags = gtk_tree_model_get_flags (tree_view->priv->model);
11487       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
11488         tree_view->priv->is_list = TRUE;
11489       else
11490         tree_view->priv->is_list = FALSE;
11491
11492       path = gtk_tree_path_new_first ();
11493       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
11494         {
11495           tree_view->priv->tree = _gtk_rbtree_new ();
11496           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
11497           _gtk_tree_view_accessible_add (tree_view, tree_view->priv->tree, NULL);
11498         }
11499       gtk_tree_path_free (path);
11500
11501       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
11502       install_presize_handler (tree_view);
11503     }
11504
11505   gtk_tree_view_real_set_cursor (tree_view, NULL, CURSOR_INVALID);
11506
11507   g_object_notify (G_OBJECT (tree_view), "model");
11508
11509   if (tree_view->priv->selection)
11510   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
11511
11512   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11513     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11514 }
11515
11516 /**
11517  * gtk_tree_view_get_selection:
11518  * @tree_view: A #GtkTreeView.
11519  *
11520  * Gets the #GtkTreeSelection associated with @tree_view.
11521  *
11522  * Return value: (transfer none): A #GtkTreeSelection object.
11523  **/
11524 GtkTreeSelection *
11525 gtk_tree_view_get_selection (GtkTreeView *tree_view)
11526 {
11527   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11528
11529   return tree_view->priv->selection;
11530 }
11531
11532 /**
11533  * gtk_tree_view_get_hadjustment:
11534  * @tree_view: A #GtkTreeView
11535  *
11536  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
11537  *
11538  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11539  *     if none is currently being used.
11540  *
11541  * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment()
11542  **/
11543 GtkAdjustment *
11544 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
11545 {
11546   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11547
11548   return gtk_tree_view_do_get_hadjustment (tree_view);
11549 }
11550
11551 static GtkAdjustment *
11552 gtk_tree_view_do_get_hadjustment (GtkTreeView *tree_view)
11553 {
11554   return tree_view->priv->hadjustment;
11555 }
11556
11557 /**
11558  * gtk_tree_view_set_hadjustment:
11559  * @tree_view: A #GtkTreeView
11560  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11561  *
11562  * Sets the #GtkAdjustment for the current horizontal aspect.
11563  *
11564  * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment()
11565  **/
11566 void
11567 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
11568                                GtkAdjustment *adjustment)
11569 {
11570   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11571   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11572
11573   gtk_tree_view_do_set_hadjustment (tree_view, adjustment);
11574 }
11575
11576 static void
11577 gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
11578                                   GtkAdjustment *adjustment)
11579 {
11580   GtkTreeViewPrivate *priv = tree_view->priv;
11581
11582   if (adjustment && priv->hadjustment == adjustment)
11583     return;
11584
11585   if (priv->hadjustment != NULL)
11586     {
11587       g_signal_handlers_disconnect_by_func (priv->hadjustment,
11588                                             gtk_tree_view_adjustment_changed,
11589                                             tree_view);
11590       g_object_unref (priv->hadjustment);
11591     }
11592
11593   if (adjustment == NULL)
11594     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11595                                      0.0, 0.0, 0.0);
11596
11597   g_signal_connect (adjustment, "value-changed",
11598                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11599   priv->hadjustment = g_object_ref_sink (adjustment);
11600   /* FIXME: Adjustment should probably be populated here with fresh values, but
11601    * internal details are too complicated for me to decipher right now.
11602    */
11603   gtk_tree_view_adjustment_changed (NULL, tree_view);
11604
11605   g_object_notify (G_OBJECT (tree_view), "hadjustment");
11606 }
11607
11608 /**
11609  * gtk_tree_view_get_vadjustment:
11610  * @tree_view: A #GtkTreeView
11611  *
11612  * Gets the #GtkAdjustment currently being used for the vertical aspect.
11613  *
11614  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11615  *     if none is currently being used.
11616  *
11617  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
11618  **/
11619 GtkAdjustment *
11620 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
11621 {
11622   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11623
11624   return gtk_tree_view_do_get_vadjustment (tree_view);
11625 }
11626
11627 static GtkAdjustment *
11628 gtk_tree_view_do_get_vadjustment (GtkTreeView *tree_view)
11629 {
11630   return tree_view->priv->vadjustment;
11631 }
11632
11633 /**
11634  * gtk_tree_view_set_vadjustment:
11635  * @tree_view: A #GtkTreeView
11636  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11637  *
11638  * Sets the #GtkAdjustment for the current vertical aspect.
11639  *
11640  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
11641  **/
11642 void
11643 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
11644                                GtkAdjustment *adjustment)
11645 {
11646   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11647   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11648
11649   gtk_tree_view_do_set_vadjustment (tree_view, adjustment);
11650 }
11651
11652 static void
11653 gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
11654                                   GtkAdjustment *adjustment)
11655 {
11656   GtkTreeViewPrivate *priv = tree_view->priv;
11657
11658   if (adjustment && priv->vadjustment == adjustment)
11659     return;
11660
11661   if (priv->vadjustment != NULL)
11662     {
11663       g_signal_handlers_disconnect_by_func (priv->vadjustment,
11664                                             gtk_tree_view_adjustment_changed,
11665                                             tree_view);
11666       g_object_unref (priv->vadjustment);
11667     }
11668
11669   if (adjustment == NULL)
11670     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11671                                      0.0, 0.0, 0.0);
11672
11673   g_signal_connect (adjustment, "value-changed",
11674                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11675   priv->vadjustment = g_object_ref_sink (adjustment);
11676   /* FIXME: Adjustment should probably be populated here with fresh values, but
11677    * internal details are too complicated for me to decipher right now.
11678    */
11679   gtk_tree_view_adjustment_changed (NULL, tree_view);
11680   g_object_notify (G_OBJECT (tree_view), "vadjustment");
11681 }
11682
11683 /* Column and header operations */
11684
11685 /**
11686  * gtk_tree_view_get_headers_visible:
11687  * @tree_view: A #GtkTreeView.
11688  *
11689  * Returns %TRUE if the headers on the @tree_view are visible.
11690  *
11691  * Return value: Whether the headers are visible or not.
11692  **/
11693 gboolean
11694 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
11695 {
11696   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11697
11698   return tree_view->priv->headers_visible;
11699 }
11700
11701 /**
11702  * gtk_tree_view_set_headers_visible:
11703  * @tree_view: A #GtkTreeView.
11704  * @headers_visible: %TRUE if the headers are visible
11705  *
11706  * Sets the visibility state of the headers.
11707  **/
11708 void
11709 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
11710                                    gboolean     headers_visible)
11711 {
11712   gint x, y;
11713   GList *list;
11714   GtkTreeViewColumn *column;
11715   GtkAllocation allocation;
11716   GtkWidget *button;
11717
11718   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11719
11720   headers_visible = !! headers_visible;
11721
11722   if (tree_view->priv->headers_visible == headers_visible)
11723     return;
11724
11725   tree_view->priv->headers_visible = headers_visible == TRUE;
11726
11727   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11728     {
11729       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
11730       if (headers_visible)
11731         {
11732           gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11733           gdk_window_move_resize (tree_view->priv->bin_window,
11734                                   x, y  + gtk_tree_view_get_effective_header_height (tree_view),
11735                                   tree_view->priv->width, allocation.height -  + gtk_tree_view_get_effective_header_height (tree_view));
11736
11737           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
11738             gtk_tree_view_map_buttons (tree_view);
11739         }
11740       else
11741         {
11742           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
11743
11744           for (list = tree_view->priv->columns; list; list = list->next)
11745             {
11746               column = list->data;
11747               button = gtk_tree_view_column_get_button (column);
11748
11749               gtk_widget_hide (button);
11750               gtk_widget_unmap (button);
11751             }
11752           gdk_window_hide (tree_view->priv->header_window);
11753         }
11754     }
11755
11756   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11757   gtk_adjustment_configure (tree_view->priv->vadjustment,
11758                             gtk_adjustment_get_value (tree_view->priv->vadjustment),
11759                             0,
11760                             tree_view->priv->height,
11761                             gtk_adjustment_get_step_increment (tree_view->priv->vadjustment),
11762                             (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2,
11763                             allocation.height - gtk_tree_view_get_effective_header_height (tree_view));
11764
11765   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11766
11767   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11768 }
11769
11770 /**
11771  * gtk_tree_view_columns_autosize:
11772  * @tree_view: A #GtkTreeView.
11773  *
11774  * Resizes all columns to their optimal width. Only works after the
11775  * treeview has been realized.
11776  **/
11777 void
11778 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11779 {
11780   gboolean dirty = FALSE;
11781   GList *list;
11782   GtkTreeViewColumn *column;
11783
11784   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11785
11786   for (list = tree_view->priv->columns; list; list = list->next)
11787     {
11788       column = list->data;
11789       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11790         continue;
11791       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11792       dirty = TRUE;
11793     }
11794
11795   if (dirty)
11796     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11797 }
11798
11799 /**
11800  * gtk_tree_view_set_headers_clickable:
11801  * @tree_view: A #GtkTreeView.
11802  * @setting: %TRUE if the columns are clickable.
11803  *
11804  * Allow the column title buttons to be clicked.
11805  **/
11806 void
11807 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11808                                      gboolean   setting)
11809 {
11810   GList *list;
11811
11812   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11813
11814   for (list = tree_view->priv->columns; list; list = list->next)
11815     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11816
11817   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11818 }
11819
11820
11821 /**
11822  * gtk_tree_view_get_headers_clickable:
11823  * @tree_view: A #GtkTreeView.
11824  *
11825  * Returns whether all header columns are clickable.
11826  *
11827  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11828  *
11829  * Since: 2.10
11830  **/
11831 gboolean
11832 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11833 {
11834   GList *list;
11835
11836   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11837
11838   for (list = tree_view->priv->columns; list; list = list->next)
11839     if (!gtk_tree_view_column_get_clickable (GTK_TREE_VIEW_COLUMN (list->data)))
11840       return FALSE;
11841
11842   return TRUE;
11843 }
11844
11845 /**
11846  * gtk_tree_view_set_rules_hint
11847  * @tree_view: a #GtkTreeView
11848  * @setting: %TRUE if the tree requires reading across rows
11849  *
11850  * This function tells GTK+ that the user interface for your
11851  * application requires users to read across tree rows and associate
11852  * cells with one another. By default, GTK+ will then render the tree
11853  * with alternating row colors. Do <emphasis>not</emphasis> use it
11854  * just because you prefer the appearance of the ruled tree; that's a
11855  * question for the theme. Some themes will draw tree rows in
11856  * alternating colors even when rules are turned off, and users who
11857  * prefer that appearance all the time can choose those themes. You
11858  * should call this function only as a <emphasis>semantic</emphasis>
11859  * hint to the theme engine that your tree makes alternating colors
11860  * useful from a functional standpoint (since it has lots of columns,
11861  * generally).
11862  *
11863  **/
11864 void
11865 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11866                               gboolean      setting)
11867 {
11868   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11869
11870   setting = setting != FALSE;
11871
11872   if (tree_view->priv->has_rules != setting)
11873     {
11874       tree_view->priv->has_rules = setting;
11875       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11876     }
11877
11878   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11879 }
11880
11881 /**
11882  * gtk_tree_view_get_rules_hint
11883  * @tree_view: a #GtkTreeView
11884  *
11885  * Gets the setting set by gtk_tree_view_set_rules_hint().
11886  *
11887  * Return value: %TRUE if rules are useful for the user of this tree
11888  **/
11889 gboolean
11890 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11891 {
11892   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11893
11894   return tree_view->priv->has_rules;
11895 }
11896
11897 /* Public Column functions
11898  */
11899
11900 /**
11901  * gtk_tree_view_append_column:
11902  * @tree_view: A #GtkTreeView.
11903  * @column: The #GtkTreeViewColumn to add.
11904  *
11905  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11906  * mode enabled, then @column must have its "sizing" property set to be
11907  * GTK_TREE_VIEW_COLUMN_FIXED.
11908  *
11909  * Return value: The number of columns in @tree_view after appending.
11910  **/
11911 gint
11912 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11913                              GtkTreeViewColumn *column)
11914 {
11915   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11916   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11917   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11918
11919   return gtk_tree_view_insert_column (tree_view, column, -1);
11920 }
11921
11922 void
11923 _gtk_tree_view_reset_header_styles (GtkTreeView *tree_view)
11924 {
11925   GList *columns;
11926
11927   for (columns = tree_view->priv->columns; columns; columns = columns->next)
11928     {
11929       GtkTreeViewColumn *column = columns->data;
11930       GtkWidget *header_widget;
11931
11932       if (!gtk_tree_view_column_get_visible (column))
11933         continue;
11934
11935       header_widget = gtk_tree_view_column_get_widget (column);
11936
11937       if (!header_widget)
11938         header_widget = gtk_tree_view_column_get_button (column);
11939
11940       gtk_widget_reset_style (header_widget);
11941     }
11942 }
11943
11944
11945 /**
11946  * gtk_tree_view_remove_column:
11947  * @tree_view: A #GtkTreeView.
11948  * @column: The #GtkTreeViewColumn to remove.
11949  *
11950  * Removes @column from @tree_view.
11951  *
11952  * Return value: The number of columns in @tree_view after removing.
11953  **/
11954 gint
11955 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11956                              GtkTreeViewColumn *column)
11957 {
11958   guint position;
11959
11960   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11961   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11962   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1);
11963
11964   if (tree_view->priv->focus_column == column)
11965     _gtk_tree_view_set_focus_column (tree_view, NULL);
11966
11967   if (tree_view->priv->edited_column == column)
11968     {
11969       gtk_tree_view_stop_editing (tree_view, TRUE);
11970
11971       /* no need to, but just to be sure ... */
11972       tree_view->priv->edited_column = NULL;
11973     }
11974
11975   if (tree_view->priv->expander_column == column)
11976     tree_view->priv->expander_column = NULL;
11977
11978   g_signal_handlers_disconnect_by_func (column,
11979                                         G_CALLBACK (column_sizing_notify),
11980                                         tree_view);
11981
11982   _gtk_tree_view_column_unset_tree_view (column);
11983
11984   position = g_list_index (tree_view->priv->columns, column);
11985
11986   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11987   tree_view->priv->n_columns--;
11988
11989   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11990     {
11991       GList *list;
11992
11993       _gtk_tree_view_column_unrealize_button (column);
11994       for (list = tree_view->priv->columns; list; list = list->next)
11995         {
11996           GtkTreeViewColumn *tmp_column;
11997
11998           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11999           if (gtk_tree_view_column_get_visible (tmp_column))
12000             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
12001         }
12002
12003       if (tree_view->priv->n_columns == 0 &&
12004           gtk_tree_view_get_headers_visible (tree_view))
12005         gdk_window_hide (tree_view->priv->header_window);
12006
12007       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12008     }
12009
12010   _gtk_tree_view_reset_header_styles (tree_view);
12011
12012   _gtk_tree_view_accessible_remove_column (tree_view, column, position);
12013
12014   g_object_unref (column);
12015   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12016
12017   return tree_view->priv->n_columns;
12018 }
12019
12020 /**
12021  * gtk_tree_view_insert_column:
12022  * @tree_view: A #GtkTreeView.
12023  * @column: The #GtkTreeViewColumn to be inserted.
12024  * @position: The position to insert @column in.
12025  *
12026  * This inserts the @column into the @tree_view at @position.  If @position is
12027  * -1, then the column is inserted at the end. If @tree_view has
12028  * "fixed_height" mode enabled, then @column must have its "sizing" property
12029  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
12030  *
12031  * Return value: The number of columns in @tree_view after insertion.
12032  **/
12033 gint
12034 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
12035                              GtkTreeViewColumn *column,
12036                              gint               position)
12037 {
12038   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12039   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
12040   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
12041
12042   if (tree_view->priv->fixed_height_mode)
12043     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
12044                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
12045
12046   if (position < 0 || position > tree_view->priv->n_columns)
12047     position = tree_view->priv->n_columns;
12048
12049   g_object_ref_sink (column);
12050
12051   if (tree_view->priv->n_columns == 0 &&
12052       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
12053       gtk_tree_view_get_headers_visible (tree_view))
12054     {
12055       gdk_window_show (tree_view->priv->header_window);
12056     }
12057
12058   g_signal_connect (column, "notify::sizing",
12059                     G_CALLBACK (column_sizing_notify), tree_view);
12060
12061   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
12062                                             column, position);
12063   tree_view->priv->n_columns++;
12064
12065   _gtk_tree_view_column_set_tree_view (column, tree_view);
12066
12067   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12068     {
12069       GList *list;
12070
12071       _gtk_tree_view_column_realize_button (column);
12072
12073       for (list = tree_view->priv->columns; list; list = list->next)
12074         {
12075           column = GTK_TREE_VIEW_COLUMN (list->data);
12076           if (gtk_tree_view_column_get_visible (column))
12077             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12078         }
12079       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12080     }
12081
12082   _gtk_tree_view_reset_header_styles (tree_view);
12083
12084   _gtk_tree_view_accessible_add_column (tree_view, column, position);
12085
12086   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12087
12088   return tree_view->priv->n_columns;
12089 }
12090
12091 /**
12092  * gtk_tree_view_insert_column_with_attributes:
12093  * @tree_view: A #GtkTreeView
12094  * @position: The position to insert the new column in
12095  * @title: The title to set the header to
12096  * @cell: The #GtkCellRenderer
12097  * @...: A %NULL-terminated list of attributes
12098  *
12099  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
12100  * @position.  If @position is -1, then the newly created column is inserted at
12101  * the end.  The column is initialized with the attributes given. If @tree_view
12102  * has "fixed_height" mode enabled, then the new column will have its sizing
12103  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12104  *
12105  * Return value: The number of columns in @tree_view after insertion.
12106  **/
12107 gint
12108 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
12109                                              gint             position,
12110                                              const gchar     *title,
12111                                              GtkCellRenderer *cell,
12112                                              ...)
12113 {
12114   GtkTreeViewColumn *column;
12115   gchar *attribute;
12116   va_list args;
12117   gint column_id;
12118
12119   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12120
12121   column = gtk_tree_view_column_new ();
12122   if (tree_view->priv->fixed_height_mode)
12123     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12124
12125   gtk_tree_view_column_set_title (column, title);
12126   gtk_tree_view_column_pack_start (column, cell, TRUE);
12127
12128   va_start (args, cell);
12129
12130   attribute = va_arg (args, gchar *);
12131
12132   while (attribute != NULL)
12133     {
12134       column_id = va_arg (args, gint);
12135       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
12136       attribute = va_arg (args, gchar *);
12137     }
12138
12139   va_end (args);
12140
12141   return gtk_tree_view_insert_column (tree_view, column, position);
12142 }
12143
12144 /**
12145  * gtk_tree_view_insert_column_with_data_func:
12146  * @tree_view: a #GtkTreeView
12147  * @position: Position to insert, -1 for append
12148  * @title: column title
12149  * @cell: cell renderer for column
12150  * @func: function to set attributes of cell renderer
12151  * @data: data for @func
12152  * @dnotify: destroy notifier for @data
12153  *
12154  * Convenience function that inserts a new column into the #GtkTreeView
12155  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
12156  * attributes (normally using data from the model). See also
12157  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
12158  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
12159  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12160  *
12161  * Return value: number of columns in the tree view post-insert
12162  **/
12163 gint
12164 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
12165                                              gint                       position,
12166                                              const gchar               *title,
12167                                              GtkCellRenderer           *cell,
12168                                              GtkTreeCellDataFunc        func,
12169                                              gpointer                   data,
12170                                              GDestroyNotify             dnotify)
12171 {
12172   GtkTreeViewColumn *column;
12173
12174   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12175
12176   column = gtk_tree_view_column_new ();
12177   if (tree_view->priv->fixed_height_mode)
12178     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12179
12180   gtk_tree_view_column_set_title (column, title);
12181   gtk_tree_view_column_pack_start (column, cell, TRUE);
12182   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
12183
12184   return gtk_tree_view_insert_column (tree_view, column, position);
12185 }
12186
12187 /**
12188  * gtk_tree_view_get_n_columns:
12189  * @tree_view: a #GtkTreeView
12190  *
12191  * Queries the number of columns in the given @tree_view.
12192  *
12193  * Returns: The number of columns in the @tree_view
12194  *
12195  * Since: 3.4
12196  **/
12197 guint
12198 gtk_tree_view_get_n_columns (GtkTreeView *tree_view)
12199 {
12200   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
12201
12202   return tree_view->priv->n_columns;
12203 }
12204
12205 /**
12206  * gtk_tree_view_get_column:
12207  * @tree_view: A #GtkTreeView.
12208  * @n: The position of the column, counting from 0.
12209  *
12210  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
12211  *
12212  * Return value: (transfer none): The #GtkTreeViewColumn, or %NULL if the
12213  *     position is outside the range of columns.
12214  **/
12215 GtkTreeViewColumn *
12216 gtk_tree_view_get_column (GtkTreeView *tree_view,
12217                           gint         n)
12218 {
12219   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12220
12221   if (n < 0 || n >= tree_view->priv->n_columns)
12222     return NULL;
12223
12224   if (tree_view->priv->columns == NULL)
12225     return NULL;
12226
12227   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
12228 }
12229
12230 /**
12231  * gtk_tree_view_get_columns:
12232  * @tree_view: A #GtkTreeView
12233  *
12234  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
12235  * The returned list must be freed with g_list_free ().
12236  *
12237  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
12238  **/
12239 GList *
12240 gtk_tree_view_get_columns (GtkTreeView *tree_view)
12241 {
12242   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12243
12244   return g_list_copy (tree_view->priv->columns);
12245 }
12246
12247 /**
12248  * gtk_tree_view_move_column_after:
12249  * @tree_view: A #GtkTreeView
12250  * @column: The #GtkTreeViewColumn to be moved.
12251  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
12252  *
12253  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
12254  * @column is placed in the first position.
12255  **/
12256 void
12257 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
12258                                  GtkTreeViewColumn *column,
12259                                  GtkTreeViewColumn *base_column)
12260 {
12261   GList *column_list_el, *base_el = NULL;
12262
12263   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12264
12265   column_list_el = g_list_find (tree_view->priv->columns, column);
12266   g_return_if_fail (column_list_el != NULL);
12267
12268   if (base_column)
12269     {
12270       base_el = g_list_find (tree_view->priv->columns, base_column);
12271       g_return_if_fail (base_el != NULL);
12272     }
12273
12274   if (column_list_el->prev == base_el)
12275     return;
12276
12277   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
12278   if (base_el == NULL)
12279     {
12280       column_list_el->prev = NULL;
12281       column_list_el->next = tree_view->priv->columns;
12282       if (column_list_el->next)
12283         column_list_el->next->prev = column_list_el;
12284       tree_view->priv->columns = column_list_el;
12285     }
12286   else
12287     {
12288       column_list_el->prev = base_el;
12289       column_list_el->next = base_el->next;
12290       if (column_list_el->next)
12291         column_list_el->next->prev = column_list_el;
12292       base_el->next = column_list_el;
12293     }
12294
12295   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12296     {
12297       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12298       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
12299     }
12300
12301   _gtk_tree_view_reset_header_styles (tree_view);
12302
12303   _gtk_tree_view_accessible_reorder_column (tree_view, column);
12304
12305   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12306 }
12307
12308 /**
12309  * gtk_tree_view_set_expander_column:
12310  * @tree_view: A #GtkTreeView
12311  * @column: %NULL, or the column to draw the expander arrow at.
12312  *
12313  * Sets the column to draw the expander arrow at. It must be in @tree_view.
12314  * If @column is %NULL, then the expander arrow is always at the first
12315  * visible column.
12316  *
12317  * If you do not want expander arrow to appear in your tree, set the
12318  * expander column to a hidden column.
12319  **/
12320 void
12321 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
12322                                    GtkTreeViewColumn *column)
12323 {
12324   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12325   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12326   g_return_if_fail (column == NULL || gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view));
12327
12328   if (tree_view->priv->expander_column != column)
12329     {
12330       tree_view->priv->expander_column = column;
12331       g_object_notify (G_OBJECT (tree_view), "expander-column");
12332     }
12333 }
12334
12335 /**
12336  * gtk_tree_view_get_expander_column:
12337  * @tree_view: A #GtkTreeView
12338  *
12339  * Returns the column that is the current expander column.
12340  * This column has the expander arrow drawn next to it.
12341  *
12342  * Return value: (transfer none): The expander column.
12343  **/
12344 GtkTreeViewColumn *
12345 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
12346 {
12347   GList *list;
12348
12349   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12350
12351   for (list = tree_view->priv->columns; list; list = list->next)
12352     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
12353       return (GtkTreeViewColumn *) list->data;
12354   return NULL;
12355 }
12356
12357
12358 /**
12359  * gtk_tree_view_set_column_drag_function:
12360  * @tree_view: A #GtkTreeView.
12361  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
12362  * @user_data: (allow-none): User data to be passed to @func, or %NULL
12363  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
12364  *
12365  * Sets a user function for determining where a column may be dropped when
12366  * dragged.  This function is called on every column pair in turn at the
12367  * beginning of a column drag to determine where a drop can take place.  The
12368  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
12369  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
12370  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
12371  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
12372  * @tree_view reverts to the default behavior of allowing all columns to be
12373  * dropped everywhere.
12374  **/
12375 void
12376 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
12377                                         GtkTreeViewColumnDropFunc  func,
12378                                         gpointer                   user_data,
12379                                         GDestroyNotify             destroy)
12380 {
12381   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12382
12383   if (tree_view->priv->column_drop_func_data_destroy)
12384     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
12385
12386   tree_view->priv->column_drop_func = func;
12387   tree_view->priv->column_drop_func_data = user_data;
12388   tree_view->priv->column_drop_func_data_destroy = destroy;
12389 }
12390
12391 /**
12392  * gtk_tree_view_scroll_to_point:
12393  * @tree_view: a #GtkTreeView
12394  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
12395  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
12396  *
12397  * Scrolls the tree view such that the top-left corner of the visible
12398  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
12399  * in tree coordinates.  The @tree_view must be realized before
12400  * this function is called.  If it isn't, you probably want to be
12401  * using gtk_tree_view_scroll_to_cell().
12402  *
12403  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
12404  **/
12405 void
12406 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
12407                                gint         tree_x,
12408                                gint         tree_y)
12409 {
12410   GtkAdjustment *hadj;
12411   GtkAdjustment *vadj;
12412
12413   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12414   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
12415
12416   hadj = tree_view->priv->hadjustment;
12417   vadj = tree_view->priv->vadjustment;
12418
12419   if (tree_x != -1)
12420     gtk_adjustment_set_value (hadj, tree_x);
12421   if (tree_y != -1)
12422     gtk_adjustment_set_value (vadj, tree_y);
12423 }
12424
12425 /**
12426  * gtk_tree_view_scroll_to_cell:
12427  * @tree_view: A #GtkTreeView.
12428  * @path: (allow-none): The path of the row to move to, or %NULL.
12429  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
12430  * @use_align: whether to use alignment arguments, or %FALSE.
12431  * @row_align: The vertical alignment of the row specified by @path.
12432  * @col_align: The horizontal alignment of the column specified by @column.
12433  *
12434  * Moves the alignments of @tree_view to the position specified by @column and
12435  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
12436  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
12437  * or @path need to be non-%NULL.  @row_align determines where the row is
12438  * placed, and @col_align determines where @column is placed.  Both are expected
12439  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
12440  * right/bottom alignment, 0.5 means center.
12441  *
12442  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
12443  * tree does the minimum amount of work to scroll the cell onto the screen.
12444  * This means that the cell will be scrolled to the edge closest to its current
12445  * position.  If the cell is currently visible on the screen, nothing is done.
12446  *
12447  * This function only works if the model is set, and @path is a valid row on the
12448  * model.  If the model changes before the @tree_view is realized, the centered
12449  * path will be modified to reflect this change.
12450  **/
12451 void
12452 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
12453                               GtkTreePath       *path,
12454                               GtkTreeViewColumn *column,
12455                               gboolean           use_align,
12456                               gfloat             row_align,
12457                               gfloat             col_align)
12458 {
12459   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12460   g_return_if_fail (tree_view->priv->model != NULL);
12461   g_return_if_fail (tree_view->priv->tree != NULL);
12462   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
12463   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
12464   g_return_if_fail (path != NULL || column != NULL);
12465
12466 #if 0
12467   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
12468            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
12469 #endif
12470   row_align = CLAMP (row_align, 0.0, 1.0);
12471   col_align = CLAMP (col_align, 0.0, 1.0);
12472
12473
12474   /* Note: Despite the benefits that come from having one code path for the
12475    * scrolling code, we short-circuit validate_visible_area's immplementation as
12476    * it is much slower than just going to the point.
12477    */
12478   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
12479       !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
12480       _gtk_widget_get_alloc_needed (GTK_WIDGET (tree_view)) ||
12481       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
12482     {
12483       if (tree_view->priv->scroll_to_path)
12484         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
12485
12486       tree_view->priv->scroll_to_path = NULL;
12487       tree_view->priv->scroll_to_column = NULL;
12488
12489       if (path)
12490         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
12491       if (column)
12492         tree_view->priv->scroll_to_column = column;
12493       tree_view->priv->scroll_to_use_align = use_align;
12494       tree_view->priv->scroll_to_row_align = row_align;
12495       tree_view->priv->scroll_to_col_align = col_align;
12496
12497       install_presize_handler (tree_view);
12498     }
12499   else
12500     {
12501       GdkRectangle cell_rect;
12502       GdkRectangle vis_rect;
12503       gint dest_x, dest_y;
12504
12505       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
12506       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
12507
12508       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
12509
12510       dest_x = vis_rect.x;
12511       dest_y = vis_rect.y;
12512
12513       if (column)
12514         {
12515           if (use_align)
12516             {
12517               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
12518             }
12519           else
12520             {
12521               if (cell_rect.x < vis_rect.x)
12522                 dest_x = cell_rect.x;
12523               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
12524                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
12525             }
12526         }
12527
12528       if (path)
12529         {
12530           if (use_align)
12531             {
12532               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
12533               dest_y = MAX (dest_y, 0);
12534             }
12535           else
12536             {
12537               if (cell_rect.y < vis_rect.y)
12538                 dest_y = cell_rect.y;
12539               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
12540                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
12541             }
12542         }
12543
12544       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
12545     }
12546 }
12547
12548 /**
12549  * gtk_tree_view_row_activated:
12550  * @tree_view: A #GtkTreeView
12551  * @path: The #GtkTreePath to be activated.
12552  * @column: The #GtkTreeViewColumn to be activated.
12553  *
12554  * Activates the cell determined by @path and @column.
12555  **/
12556 void
12557 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
12558                              GtkTreePath       *path,
12559                              GtkTreeViewColumn *column)
12560 {
12561   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12562
12563   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
12564 }
12565
12566
12567 static void
12568 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
12569                                           GtkRBNode *node,
12570                                           gpointer   data)
12571 {
12572   GtkTreeView *tree_view = data;
12573
12574   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
12575       node->children)
12576     {
12577       GtkTreePath *path;
12578       GtkTreeIter iter;
12579
12580       path = _gtk_tree_path_new_from_rbtree (tree, node);
12581       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12582
12583       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12584
12585       gtk_tree_path_free (path);
12586     }
12587
12588   if (node->children)
12589     _gtk_rbtree_traverse (node->children,
12590                           node->children->root,
12591                           G_PRE_ORDER,
12592                           gtk_tree_view_expand_all_emission_helper,
12593                           tree_view);
12594 }
12595
12596 /**
12597  * gtk_tree_view_expand_all:
12598  * @tree_view: A #GtkTreeView.
12599  *
12600  * Recursively expands all nodes in the @tree_view.
12601  **/
12602 void
12603 gtk_tree_view_expand_all (GtkTreeView *tree_view)
12604 {
12605   GtkTreePath *path;
12606   GtkRBTree *tree;
12607   GtkRBNode *node;
12608
12609   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12610
12611   if (tree_view->priv->tree == NULL)
12612     return;
12613
12614   path = gtk_tree_path_new_first ();
12615   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12616
12617   while (node)
12618     {
12619       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
12620       node = _gtk_rbtree_next (tree, node);
12621       gtk_tree_path_next (path);
12622   }
12623
12624   gtk_tree_path_free (path);
12625 }
12626
12627 /**
12628  * gtk_tree_view_collapse_all:
12629  * @tree_view: A #GtkTreeView.
12630  *
12631  * Recursively collapses all visible, expanded nodes in @tree_view.
12632  **/
12633 void
12634 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
12635 {
12636   GtkRBTree *tree;
12637   GtkRBNode *node;
12638   GtkTreePath *path;
12639   gint *indices;
12640
12641   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12642
12643   if (tree_view->priv->tree == NULL)
12644     return;
12645
12646   path = gtk_tree_path_new ();
12647   gtk_tree_path_down (path);
12648   indices = gtk_tree_path_get_indices (path);
12649
12650   tree = tree_view->priv->tree;
12651   node = _gtk_rbtree_first (tree);
12652
12653   while (node)
12654     {
12655       if (node->children)
12656         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12657       indices[0]++;
12658       node = _gtk_rbtree_next (tree, node);
12659     }
12660
12661   gtk_tree_path_free (path);
12662 }
12663
12664 /**
12665  * gtk_tree_view_expand_to_path:
12666  * @tree_view: A #GtkTreeView.
12667  * @path: path to a row.
12668  *
12669  * Expands the row at @path. This will also expand all parent rows of
12670  * @path as necessary.
12671  *
12672  * Since: 2.2
12673  **/
12674 void
12675 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
12676                               GtkTreePath *path)
12677 {
12678   gint i, depth;
12679   gint *indices;
12680   GtkTreePath *tmp;
12681
12682   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12683   g_return_if_fail (path != NULL);
12684
12685   depth = gtk_tree_path_get_depth (path);
12686   indices = gtk_tree_path_get_indices (path);
12687
12688   tmp = gtk_tree_path_new ();
12689   g_return_if_fail (tmp != NULL);
12690
12691   for (i = 0; i < depth; i++)
12692     {
12693       gtk_tree_path_append_index (tmp, indices[i]);
12694       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12695     }
12696
12697   gtk_tree_path_free (tmp);
12698 }
12699
12700 /* FIXME the bool return values for expand_row and collapse_row are
12701  * not analagous; they should be TRUE if the row had children and
12702  * was not already in the requested state.
12703  */
12704
12705
12706 static gboolean
12707 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12708                                GtkTreePath *path,
12709                                GtkRBTree   *tree,
12710                                GtkRBNode   *node,
12711                                gboolean     open_all,
12712                                gboolean     animate)
12713 {
12714   GtkTreeIter iter;
12715   GtkTreeIter temp;
12716   gboolean expand;
12717
12718   if (animate)
12719     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12720                   "gtk-enable-animations", &animate,
12721                   NULL);
12722
12723   remove_auto_expand_timeout (tree_view);
12724
12725   if (node->children && !open_all)
12726     return FALSE;
12727
12728   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12729     return FALSE;
12730
12731   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12732   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12733     return FALSE;
12734
12735
12736    if (node->children && open_all)
12737     {
12738       gboolean retval = FALSE;
12739       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12740
12741       gtk_tree_path_append_index (tmp_path, 0);
12742       tree = node->children;
12743       node = _gtk_rbtree_first (tree);
12744       /* try to expand the children */
12745       do
12746         {
12747          gboolean t;
12748          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12749                                             TRUE, animate);
12750          if (t)
12751            retval = TRUE;
12752
12753          gtk_tree_path_next (tmp_path);
12754          node = _gtk_rbtree_next (tree, node);
12755        }
12756       while (node != NULL);
12757
12758       gtk_tree_path_free (tmp_path);
12759
12760       return retval;
12761     }
12762
12763   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12764
12765   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12766     return FALSE;
12767
12768   if (expand)
12769     return FALSE;
12770
12771   node->children = _gtk_rbtree_new ();
12772   node->children->parent_tree = tree;
12773   node->children->parent_node = node;
12774
12775   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12776
12777   gtk_tree_view_build_tree (tree_view,
12778                             node->children,
12779                             &temp,
12780                             gtk_tree_path_get_depth (path) + 1,
12781                             open_all);
12782
12783   _gtk_tree_view_accessible_add (tree_view, node->children, NULL);
12784   _gtk_tree_view_accessible_add_state (tree_view,
12785                                        tree, node,
12786                                        GTK_CELL_RENDERER_EXPANDED);
12787
12788   if (animate)
12789     {
12790       GtkStyleContext *context;
12791
12792       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
12793
12794       gtk_style_context_save (context);
12795       gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
12796
12797       gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
12798                                              node, GTK_STATE_ACTIVE, TRUE);
12799
12800       _gtk_style_context_invalidate_animation_areas (context);
12801       gtk_style_context_restore (context);
12802     }
12803
12804   install_presize_handler (tree_view);
12805
12806   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12807   if (open_all && node->children)
12808     {
12809       _gtk_rbtree_traverse (node->children,
12810                             node->children->root,
12811                             G_PRE_ORDER,
12812                             gtk_tree_view_expand_all_emission_helper,
12813                             tree_view);
12814     }
12815   return TRUE;
12816 }
12817
12818
12819 /**
12820  * gtk_tree_view_expand_row:
12821  * @tree_view: a #GtkTreeView
12822  * @path: path to a row
12823  * @open_all: whether to recursively expand, or just expand immediate children
12824  *
12825  * Opens the row so its children are visible.
12826  *
12827  * Return value: %TRUE if the row existed and had children
12828  **/
12829 gboolean
12830 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12831                           GtkTreePath *path,
12832                           gboolean     open_all)
12833 {
12834   GtkRBTree *tree;
12835   GtkRBNode *node;
12836
12837   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12838   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12839   g_return_val_if_fail (path != NULL, FALSE);
12840
12841   if (_gtk_tree_view_find_node (tree_view,
12842                                 path,
12843                                 &tree,
12844                                 &node))
12845     return FALSE;
12846
12847   if (tree != NULL)
12848     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12849   else
12850     return FALSE;
12851 }
12852
12853 static gboolean
12854 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12855                                  GtkTreePath *path,
12856                                  GtkRBTree   *tree,
12857                                  GtkRBNode   *node,
12858                                  gboolean     animate)
12859 {
12860   GtkTreeIter iter;
12861   GtkTreeIter children;
12862   gboolean collapse;
12863   gint x, y;
12864   GList *list;
12865   GdkWindow *child;
12866   gboolean selection_changed, cursor_changed;
12867
12868   if (animate)
12869     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12870                   "gtk-enable-animations", &animate,
12871                   NULL);
12872
12873   remove_auto_expand_timeout (tree_view);
12874
12875   if (node->children == NULL)
12876     return FALSE;
12877   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12878
12879   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12880
12881   if (collapse)
12882     return FALSE;
12883
12884   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12885    * a chance to prelight the correct node below */
12886
12887   if (tree_view->priv->prelight_tree)
12888     {
12889       GtkRBTree *parent_tree;
12890       GtkRBNode *parent_node;
12891
12892       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12893       parent_node = tree_view->priv->prelight_tree->parent_node;
12894       while (parent_tree)
12895         {
12896           if (parent_tree == tree && parent_node == node)
12897             {
12898               ensure_unprelighted (tree_view);
12899               break;
12900             }
12901           parent_node = parent_tree->parent_node;
12902           parent_tree = parent_tree->parent_tree;
12903         }
12904     }
12905
12906   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12907
12908   for (list = tree_view->priv->columns; list; list = list->next)
12909     {
12910       GtkTreeViewColumn *column = list->data;
12911
12912       if (gtk_tree_view_column_get_visible (column) == FALSE)
12913         continue;
12914       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12915         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12916     }
12917
12918   if (tree_view->priv->destroy_count_func)
12919     {
12920       GtkTreePath *child_path;
12921       gint child_count = 0;
12922       child_path = gtk_tree_path_copy (path);
12923       gtk_tree_path_down (child_path);
12924       if (node->children)
12925         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12926       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12927       gtk_tree_path_free (child_path);
12928     }
12929
12930   if (tree_view->priv->cursor_node)
12931     {
12932       cursor_changed = (node->children == tree_view->priv->cursor_tree)
12933                        || _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree);
12934     }
12935   else
12936     cursor_changed = FALSE;
12937
12938   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12939     {
12940       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12941       if (gtk_tree_path_is_ancestor (path, anchor_path))
12942         {
12943           gtk_tree_row_reference_free (tree_view->priv->anchor);
12944           tree_view->priv->anchor = NULL;
12945         }
12946       gtk_tree_path_free (anchor_path);
12947     }
12948
12949   selection_changed = gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children);
12950
12951   /* Stop a pending double click */
12952   tree_view->priv->last_button_x = -1;
12953   tree_view->priv->last_button_y = -1;
12954
12955   _gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
12956   _gtk_tree_view_accessible_remove_state (tree_view,
12957                                           tree, node,
12958                                           GTK_CELL_RENDERER_EXPANDED);
12959
12960   _gtk_rbtree_remove (node->children);
12961
12962   if (cursor_changed)
12963     gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CURSOR_INVALID);
12964   if (selection_changed)
12965     g_signal_emit_by_name (tree_view->priv->selection, "changed");
12966
12967   if (animate)
12968     {
12969       GtkStyleContext *context;
12970
12971       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
12972
12973       gtk_style_context_save (context);
12974       gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
12975
12976       gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
12977                                              node, GTK_STATE_ACTIVE, FALSE);
12978
12979       _gtk_style_context_invalidate_animation_areas (context);
12980       gtk_style_context_restore (context);
12981     }
12982
12983   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12984     {
12985       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12986     }
12987
12988   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12989
12990   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12991     {
12992       /* now that we've collapsed all rows, we want to try to set the prelight
12993        * again. To do this, we fake a motion event and send it to ourselves. */
12994
12995       child = gdk_window_get_device_position (gdk_window_get_parent (tree_view->priv->bin_window),
12996                                               gdk_device_manager_get_client_pointer (
12997                                                 gdk_display_get_device_manager (
12998                                                   gtk_widget_get_display (GTK_WIDGET (tree_view)))),
12999                                               &x, &y, NULL);
13000       if (child == tree_view->priv->bin_window)
13001         {
13002           GdkEventMotion event;
13003           gint child_x, child_y;
13004
13005           gdk_window_get_position (child, &child_x, &child_y);
13006
13007           event.window = tree_view->priv->bin_window;
13008           event.x = x - child_x;
13009           event.y = y - child_y;
13010
13011           /* despite the fact this isn't a real event, I'm almost positive it will
13012            * never trigger a drag event.  maybe_drag is the only function that uses
13013            * more than just event.x and event.y. */
13014           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
13015         }
13016     }
13017
13018   return TRUE;
13019 }
13020
13021 /**
13022  * gtk_tree_view_collapse_row:
13023  * @tree_view: a #GtkTreeView
13024  * @path: path to a row in the @tree_view
13025  *
13026  * Collapses a row (hides its child rows, if they exist).
13027  *
13028  * Return value: %TRUE if the row was collapsed.
13029  **/
13030 gboolean
13031 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
13032                             GtkTreePath *path)
13033 {
13034   GtkRBTree *tree;
13035   GtkRBNode *node;
13036
13037   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13038   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
13039   g_return_val_if_fail (path != NULL, FALSE);
13040
13041   if (_gtk_tree_view_find_node (tree_view,
13042                                 path,
13043                                 &tree,
13044                                 &node))
13045     return FALSE;
13046
13047   if (tree == NULL || node->children == NULL)
13048     return FALSE;
13049
13050   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
13051 }
13052
13053 static void
13054 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
13055                                         GtkRBTree              *tree,
13056                                         GtkTreePath            *path,
13057                                         GtkTreeViewMappingFunc  func,
13058                                         gpointer                user_data)
13059 {
13060   GtkRBNode *node;
13061
13062   if (tree == NULL || tree->root == NULL)
13063     return;
13064
13065   node = _gtk_rbtree_first (tree);
13066
13067   while (node)
13068     {
13069       if (node->children)
13070         {
13071           (* func) (tree_view, path, user_data);
13072           gtk_tree_path_down (path);
13073           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
13074           gtk_tree_path_up (path);
13075         }
13076       gtk_tree_path_next (path);
13077       node = _gtk_rbtree_next (tree, node);
13078     }
13079 }
13080
13081 /**
13082  * gtk_tree_view_map_expanded_rows:
13083  * @tree_view: A #GtkTreeView
13084  * @func: (scope call): A function to be called
13085  * @data: User data to be passed to the function.
13086  *
13087  * Calls @func on all expanded rows.
13088  **/
13089 void
13090 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
13091                                  GtkTreeViewMappingFunc  func,
13092                                  gpointer                user_data)
13093 {
13094   GtkTreePath *path;
13095
13096   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13097   g_return_if_fail (func != NULL);
13098
13099   path = gtk_tree_path_new_first ();
13100
13101   gtk_tree_view_map_expanded_rows_helper (tree_view,
13102                                           tree_view->priv->tree,
13103                                           path, func, user_data);
13104
13105   gtk_tree_path_free (path);
13106 }
13107
13108 /**
13109  * gtk_tree_view_row_expanded:
13110  * @tree_view: A #GtkTreeView.
13111  * @path: A #GtkTreePath to test expansion state.
13112  *
13113  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
13114  *
13115  * Return value: %TRUE if #path is expanded.
13116  **/
13117 gboolean
13118 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
13119                             GtkTreePath *path)
13120 {
13121   GtkRBTree *tree;
13122   GtkRBNode *node;
13123
13124   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13125   g_return_val_if_fail (path != NULL, FALSE);
13126
13127   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13128
13129   if (node == NULL)
13130     return FALSE;
13131
13132   return (node->children != NULL);
13133 }
13134
13135 /**
13136  * gtk_tree_view_get_reorderable:
13137  * @tree_view: a #GtkTreeView
13138  *
13139  * Retrieves whether the user can reorder the tree via drag-and-drop. See
13140  * gtk_tree_view_set_reorderable().
13141  *
13142  * Return value: %TRUE if the tree can be reordered.
13143  **/
13144 gboolean
13145 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
13146 {
13147   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13148
13149   return tree_view->priv->reorderable;
13150 }
13151
13152 /**
13153  * gtk_tree_view_set_reorderable:
13154  * @tree_view: A #GtkTreeView.
13155  * @reorderable: %TRUE, if the tree can be reordered.
13156  *
13157  * This function is a convenience function to allow you to reorder
13158  * models that support the #GtkTreeDragSourceIface and the
13159  * #GtkTreeDragDestIface.  Both #GtkTreeStore and #GtkListStore support
13160  * these.  If @reorderable is %TRUE, then the user can reorder the
13161  * model by dragging and dropping rows. The developer can listen to
13162  * these changes by connecting to the model's row_inserted and
13163  * row_deleted signals. The reordering is implemented by setting up
13164  * the tree view as a drag source and destination. Therefore, drag and
13165  * drop can not be used in a reorderable view for any other purpose.
13166  *
13167  * This function does not give you any degree of control over the order -- any
13168  * reordering is allowed.  If more control is needed, you should probably
13169  * handle drag and drop manually.
13170  **/
13171 void
13172 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
13173                                gboolean     reorderable)
13174 {
13175   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13176
13177   reorderable = reorderable != FALSE;
13178
13179   if (tree_view->priv->reorderable == reorderable)
13180     return;
13181
13182   if (reorderable)
13183     {
13184       const GtkTargetEntry row_targets[] = {
13185         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
13186       };
13187
13188       gtk_tree_view_enable_model_drag_source (tree_view,
13189                                               GDK_BUTTON1_MASK,
13190                                               row_targets,
13191                                               G_N_ELEMENTS (row_targets),
13192                                               GDK_ACTION_MOVE);
13193       gtk_tree_view_enable_model_drag_dest (tree_view,
13194                                             row_targets,
13195                                             G_N_ELEMENTS (row_targets),
13196                                             GDK_ACTION_MOVE);
13197     }
13198   else
13199     {
13200       gtk_tree_view_unset_rows_drag_source (tree_view);
13201       gtk_tree_view_unset_rows_drag_dest (tree_view);
13202     }
13203
13204   tree_view->priv->reorderable = reorderable;
13205
13206   g_object_notify (G_OBJECT (tree_view), "reorderable");
13207 }
13208
13209 static void
13210 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
13211                                GtkTreePath     *path,
13212                                SetCursorFlags   flags)
13213 {
13214   if (!(flags & CURSOR_INVALID) && tree_view->priv->cursor_node)
13215     {
13216       _gtk_tree_view_accessible_remove_state (tree_view,
13217                                               tree_view->priv->cursor_tree,
13218                                               tree_view->priv->cursor_node,
13219                                               GTK_CELL_RENDERER_FOCUSED);
13220       _gtk_tree_view_queue_draw_node (tree_view,
13221                                       tree_view->priv->cursor_tree,
13222                                       tree_view->priv->cursor_node,
13223                                       NULL);
13224     }
13225
13226   /* One cannot set the cursor on a separator.   Also, if
13227    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
13228    * before finding the tree and node belonging to path.  The
13229    * path maps to a non-existing path and we will silently bail out.
13230    * We unset tree and node to avoid further processing.
13231    */
13232   if (path == NULL ||
13233       row_is_separator (tree_view, NULL, path)
13234       || _gtk_tree_view_find_node (tree_view,
13235                                    path,
13236                                    &tree_view->priv->cursor_tree,
13237                                    &tree_view->priv->cursor_node))
13238     {
13239       tree_view->priv->cursor_tree = NULL;
13240       tree_view->priv->cursor_node = NULL;
13241     }
13242
13243   if (tree_view->priv->cursor_node != NULL)
13244     {
13245       GtkRBTree *new_tree = NULL;
13246       GtkRBNode *new_node = NULL;
13247
13248       if ((flags & CLEAR_AND_SELECT) && !tree_view->priv->modify_selection_pressed)
13249         {
13250           GtkTreeSelectMode mode = 0;
13251
13252           if (tree_view->priv->extend_selection_pressed)
13253             mode |= GTK_TREE_SELECT_MODE_EXTEND;
13254
13255           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
13256                                                     tree_view->priv->cursor_node,
13257                                                     tree_view->priv->cursor_tree,
13258                                                     path,
13259                                                     mode,
13260                                                     FALSE);
13261         }
13262
13263       /* We have to re-find tree and node here again, somebody might have
13264        * cleared the node or the whole tree in the GtkTreeSelection::changed
13265        * callback. If the nodes differ we bail out here.
13266        */
13267       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
13268
13269       if (tree_view->priv->cursor_node != new_node)
13270         return;
13271
13272       if (flags & CLAMP_NODE)
13273         {
13274           gtk_tree_view_clamp_node_visible (tree_view,
13275                                             tree_view->priv->cursor_tree,
13276                                             tree_view->priv->cursor_node);
13277           _gtk_tree_view_queue_draw_node (tree_view,
13278                                           tree_view->priv->cursor_tree,
13279                                           tree_view->priv->cursor_node,
13280                                           NULL);
13281         }
13282
13283       _gtk_tree_view_accessible_add_state (tree_view,
13284                                            tree_view->priv->cursor_tree,
13285                                            tree_view->priv->cursor_node,
13286                                            GTK_CELL_RENDERER_FOCUSED);
13287     }
13288
13289   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
13290 }
13291
13292 /**
13293  * gtk_tree_view_get_cursor:
13294  * @tree_view: A #GtkTreeView
13295  * @path: (out) (transfer full) (allow-none): A pointer to be filled with the current cursor path, or %NULL
13296  * @focus_column: (out) (transfer none) (allow-none): A pointer to be filled with the current focus column, or %NULL
13297  *
13298  * Fills in @path and @focus_column with the current path and focus column.  If
13299  * the cursor isn't currently set, then *@path will be %NULL.  If no column
13300  * currently has focus, then *@focus_column will be %NULL.
13301  *
13302  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
13303  * you are done with it.
13304  **/
13305 void
13306 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
13307                           GtkTreePath       **path,
13308                           GtkTreeViewColumn **focus_column)
13309 {
13310   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13311
13312   if (path)
13313     {
13314       if (tree_view->priv->cursor_node)
13315         *path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
13316                                                 tree_view->priv->cursor_node);
13317       else
13318         *path = NULL;
13319     }
13320
13321   if (focus_column)
13322     {
13323       *focus_column = tree_view->priv->focus_column;
13324     }
13325 }
13326
13327 /**
13328  * gtk_tree_view_set_cursor:
13329  * @tree_view: A #GtkTreeView
13330  * @path: A #GtkTreePath
13331  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13332  * @start_editing: %TRUE if the specified cell should start being edited.
13333  *
13334  * Sets the current keyboard focus to be at @path, and selects it.  This is
13335  * useful when you want to focus the user's attention on a particular row.  If
13336  * @focus_column is not %NULL, then focus is given to the column specified by
13337  * it. Additionally, if @focus_column is specified, and @start_editing is
13338  * %TRUE, then editing should be started in the specified cell.
13339  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
13340  * in order to give keyboard focus to the widget.  Please note that editing
13341  * can only happen when the widget is realized.
13342  *
13343  * If @path is invalid for @model, the current cursor (if any) will be unset
13344  * and the function will return without failing.
13345  **/
13346 void
13347 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
13348                           GtkTreePath       *path,
13349                           GtkTreeViewColumn *focus_column,
13350                           gboolean           start_editing)
13351 {
13352   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
13353                                     NULL, start_editing);
13354 }
13355
13356 /**
13357  * gtk_tree_view_set_cursor_on_cell:
13358  * @tree_view: A #GtkTreeView
13359  * @path: A #GtkTreePath
13360  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13361  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
13362  * @start_editing: %TRUE if the specified cell should start being edited.
13363  *
13364  * Sets the current keyboard focus to be at @path, and selects it.  This is
13365  * useful when you want to focus the user's attention on a particular row.  If
13366  * @focus_column is not %NULL, then focus is given to the column specified by
13367  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
13368  * contains 2 or more editable or activatable cells, then focus is given to
13369  * the cell specified by @focus_cell. Additionally, if @focus_column is
13370  * specified, and @start_editing is %TRUE, then editing should be started in
13371  * the specified cell.  This function is often followed by
13372  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
13373  * widget.  Please note that editing can only happen when the widget is
13374  * realized.
13375  *
13376  * If @path is invalid for @model, the current cursor (if any) will be unset
13377  * and the function will return without failing.
13378  *
13379  * Since: 2.2
13380  **/
13381 void
13382 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
13383                                   GtkTreePath       *path,
13384                                   GtkTreeViewColumn *focus_column,
13385                                   GtkCellRenderer   *focus_cell,
13386                                   gboolean           start_editing)
13387 {
13388   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13389   g_return_if_fail (path != NULL);
13390   g_return_if_fail (focus_column == NULL || GTK_IS_TREE_VIEW_COLUMN (focus_column));
13391
13392   if (!tree_view->priv->model)
13393     return;
13394
13395   if (focus_cell)
13396     {
13397       g_return_if_fail (focus_column);
13398       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
13399     }
13400
13401   /* cancel the current editing, if it exists */
13402   if (tree_view->priv->edited_column &&
13403       gtk_cell_area_get_edit_widget
13404       (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column))))
13405     gtk_tree_view_stop_editing (tree_view, TRUE);
13406
13407   gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
13408
13409   if (focus_column &&
13410       gtk_tree_view_column_get_visible (focus_column))
13411     {
13412       GList *list;
13413       gboolean column_in_tree = FALSE;
13414
13415       for (list = tree_view->priv->columns; list; list = list->next)
13416         if (list->data == focus_column)
13417           {
13418             column_in_tree = TRUE;
13419             break;
13420           }
13421       g_return_if_fail (column_in_tree);
13422       _gtk_tree_view_set_focus_column (tree_view, focus_column);
13423       if (focus_cell)
13424         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
13425       if (start_editing)
13426         gtk_tree_view_start_editing (tree_view, path, TRUE);
13427     }
13428 }
13429
13430 /**
13431  * gtk_tree_view_get_bin_window:
13432  * @tree_view: A #GtkTreeView
13433  *
13434  * Returns the window that @tree_view renders to.
13435  * This is used primarily to compare to <literal>event->window</literal>
13436  * to confirm that the event on @tree_view is on the right window.
13437  *
13438  * Return value: (transfer none): A #GdkWindow, or %NULL when @tree_view
13439  *     hasn't been realized yet
13440  **/
13441 GdkWindow *
13442 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
13443 {
13444   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13445
13446   return tree_view->priv->bin_window;
13447 }
13448
13449 /**
13450  * gtk_tree_view_get_path_at_pos:
13451  * @tree_view: A #GtkTreeView.
13452  * @x: The x position to be identified (relative to bin_window).
13453  * @y: The y position to be identified (relative to bin_window).
13454  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
13455  * @column: (out) (transfer none) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
13456  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
13457  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
13458  *
13459  * Finds the path at the point (@x, @y), relative to bin_window coordinates
13460  * (please see gtk_tree_view_get_bin_window()).
13461  * That is, @x and @y are relative to an events coordinates. @x and @y must
13462  * come from an event on the @tree_view only where <literal>event->window ==
13463  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
13464  * things like popup menus. If @path is non-%NULL, then it will be filled
13465  * with the #GtkTreePath at that point.  This path should be freed with
13466  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
13467  * with the column at that point.  @cell_x and @cell_y return the coordinates
13468  * relative to the cell background (i.e. the @background_area passed to
13469  * gtk_cell_renderer_render()).  This function is only meaningful if
13470  * @tree_view is realized.  Therefore this function will always return %FALSE
13471  * if @tree_view is not realized or does not have a model.
13472  *
13473  * For converting widget coordinates (eg. the ones you get from
13474  * GtkWidget::query-tooltip), please see
13475  * gtk_tree_view_convert_widget_to_bin_window_coords().
13476  *
13477  * Return value: %TRUE if a row exists at that coordinate.
13478  **/
13479 gboolean
13480 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
13481                                gint                x,
13482                                gint                y,
13483                                GtkTreePath       **path,
13484                                GtkTreeViewColumn **column,
13485                                gint               *cell_x,
13486                                gint               *cell_y)
13487 {
13488   GtkRBTree *tree;
13489   GtkRBNode *node;
13490   gint y_offset;
13491
13492   g_return_val_if_fail (tree_view != NULL, FALSE);
13493
13494   if (path)
13495     *path = NULL;
13496   if (column)
13497     *column = NULL;
13498
13499   if (tree_view->priv->bin_window == NULL)
13500     return FALSE;
13501
13502   if (tree_view->priv->tree == NULL)
13503     return FALSE;
13504
13505   if (x > gtk_adjustment_get_upper (tree_view->priv->hadjustment))
13506     return FALSE;
13507
13508   if (x < 0 || y < 0)
13509     return FALSE;
13510
13511   if (column || cell_x)
13512     {
13513       GtkTreeViewColumn *tmp_column;
13514       GtkTreeViewColumn *last_column = NULL;
13515       GList *list;
13516       gint remaining_x = x;
13517       gboolean found = FALSE;
13518       gboolean rtl;
13519       gint width;
13520
13521       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
13522       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13523            list;
13524            list = (rtl ? list->prev : list->next))
13525         {
13526           tmp_column = list->data;
13527
13528           if (gtk_tree_view_column_get_visible (tmp_column) == FALSE)
13529             continue;
13530
13531           last_column = tmp_column;
13532           width = gtk_tree_view_column_get_width (tmp_column);
13533           if (remaining_x <= width)
13534             {
13535               found = TRUE;
13536
13537               if (column)
13538                 *column = tmp_column;
13539
13540               if (cell_x)
13541                 *cell_x = remaining_x;
13542
13543               break;
13544             }
13545           remaining_x -= width;
13546         }
13547
13548       /* If found is FALSE and there is a last_column, then it the remainder
13549        * space is in that area
13550        */
13551       if (!found)
13552         {
13553           if (last_column)
13554             {
13555               if (column)
13556                 *column = last_column;
13557
13558               if (cell_x)
13559                 *cell_x = gtk_tree_view_column_get_width (last_column) + remaining_x;
13560             }
13561           else
13562             {
13563               return FALSE;
13564             }
13565         }
13566     }
13567
13568   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
13569                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
13570                                       &tree, &node);
13571
13572   if (tree == NULL)
13573     return FALSE;
13574
13575   if (cell_y)
13576     *cell_y = y_offset;
13577
13578   if (path)
13579     *path = _gtk_tree_path_new_from_rbtree (tree, node);
13580
13581   return TRUE;
13582 }
13583
13584
13585 static inline gint
13586 gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
13587                                     GtkRBNode   *node,
13588                                     gint         vertical_separator)
13589 {
13590   int height;
13591
13592   /* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
13593    * i.e. just the cells, no spacing.
13594    *
13595    * The cell area height is at least expander_size - vertical_separator.
13596    * For regular nodes, the height is then at least expander_size. We should
13597    * be able to enforce the expander_size minimum here, because this
13598    * function will not be called for irregular (e.g. separator) rows.
13599    */
13600   height = gtk_tree_view_get_row_height (tree_view, node);
13601   if (height < tree_view->priv->expander_size)
13602     height = tree_view->priv->expander_size;
13603
13604   return height - vertical_separator;
13605 }
13606
13607 static inline gint
13608 gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
13609                                       GtkRBTree   *tree,
13610                                       GtkRBNode   *node,
13611                                       gint         vertical_separator)
13612 {
13613   int offset;
13614
13615   offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13616   offset += vertical_separator / 2;
13617
13618   return offset;
13619 }
13620
13621 /**
13622  * gtk_tree_view_get_cell_area:
13623  * @tree_view: a #GtkTreeView
13624  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13625  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
13626  * @rect: (out): rectangle to fill with cell rect
13627  *
13628  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13629  * row specified by @path and the column specified by @column.  If @path is
13630  * %NULL, or points to a path not currently displayed, the @y and @height fields
13631  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13632  * fields will be filled with 0.  The sum of all cell rects does not cover the
13633  * entire tree; there are extra pixels in between rows, for example. The
13634  * returned rectangle is equivalent to the @cell_area passed to
13635  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
13636  * realized.
13637  **/
13638 void
13639 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
13640                              GtkTreePath        *path,
13641                              GtkTreeViewColumn  *column,
13642                              GdkRectangle       *rect)
13643 {
13644   GtkRBTree *tree = NULL;
13645   GtkRBNode *node = NULL;
13646   gint vertical_separator;
13647   gint horizontal_separator;
13648
13649   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13650   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13651   g_return_if_fail (rect != NULL);
13652   g_return_if_fail (!column || gtk_tree_view_column_get_tree_view (column) == (GtkWidget *) tree_view);
13653   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
13654
13655   gtk_widget_style_get (GTK_WIDGET (tree_view),
13656                         "vertical-separator", &vertical_separator,
13657                         "horizontal-separator", &horizontal_separator,
13658                         NULL);
13659
13660   rect->x = 0;
13661   rect->y = 0;
13662   rect->width = 0;
13663   rect->height = 0;
13664
13665   if (column)
13666     {
13667       rect->x = gtk_tree_view_column_get_x_offset (column) + horizontal_separator/2;
13668       rect->width = gtk_tree_view_column_get_width (column) - horizontal_separator;
13669     }
13670
13671   if (path)
13672     {
13673       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13674
13675       /* Get vertical coords */
13676       if ((!ret && tree == NULL) || ret)
13677         return;
13678
13679       if (row_is_separator (tree_view, NULL, path))
13680         {
13681           /* There isn't really a "cell area" for separator, so we
13682            * return the y, height values for background area instead.
13683            */
13684           rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13685           rect->height = gtk_tree_view_get_row_height (tree_view, node);
13686         }
13687       else
13688         {
13689           rect->y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
13690                                                           vertical_separator);
13691           rect->height = gtk_tree_view_get_cell_area_height (tree_view, node,
13692                                                              vertical_separator);
13693         }
13694
13695       if (column &&
13696           gtk_tree_view_is_expander_column (tree_view, column))
13697         {
13698           gint depth = gtk_tree_path_get_depth (path);
13699           gboolean rtl;
13700
13701           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13702
13703           if (!rtl)
13704             rect->x += (depth - 1) * tree_view->priv->level_indentation;
13705           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
13706
13707           if (gtk_tree_view_draw_expanders (tree_view))
13708             {
13709               if (!rtl)
13710                 rect->x += depth * tree_view->priv->expander_size;
13711               rect->width -= depth * tree_view->priv->expander_size;
13712             }
13713
13714           rect->width = MAX (rect->width, 0);
13715         }
13716     }
13717 }
13718
13719 static inline gint
13720 gtk_tree_view_get_row_height (GtkTreeView *tree_view,
13721                               GtkRBNode   *node)
13722 {
13723   int height;
13724
13725   /* The "background" areas of all rows/cells add up to cover the entire tree.
13726    * The background includes all inter-row and inter-cell spacing.
13727    *
13728    * If the row pointed at by node does not have a height set, we default
13729    * to expander_size, which is the minimum height for regular nodes.
13730    * Non-regular nodes (e.g. separators) can have a height set smaller
13731    * than expander_size and should not be overruled here.
13732    */
13733   height = GTK_RBNODE_GET_HEIGHT (node);
13734   if (height <= 0)
13735     height = tree_view->priv->expander_size;
13736
13737   return height;
13738 }
13739
13740 static inline gint
13741 gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
13742                                 GtkRBTree   *tree,
13743                                 GtkRBNode   *node)
13744 {
13745   int offset;
13746
13747   offset = _gtk_rbtree_node_find_offset (tree, node);
13748
13749   return RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, offset);
13750 }
13751
13752 /**
13753  * gtk_tree_view_get_background_area:
13754  * @tree_view: a #GtkTreeView
13755  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13756  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
13757  * @rect: (out): rectangle to fill with cell background rect
13758  *
13759  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13760  * row specified by @path and the column specified by @column.  If @path is
13761  * %NULL, or points to a node not found in the tree, the @y and @height fields of
13762  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13763  * fields will be filled with 0.  The returned rectangle is equivalent to the
13764  * @background_area passed to gtk_cell_renderer_render().  These background
13765  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
13766  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
13767  * itself, excluding surrounding borders and the tree expander area.
13768  *
13769  **/
13770 void
13771 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
13772                                    GtkTreePath        *path,
13773                                    GtkTreeViewColumn  *column,
13774                                    GdkRectangle       *rect)
13775 {
13776   GtkRBTree *tree = NULL;
13777   GtkRBNode *node = NULL;
13778
13779   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13780   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13781   g_return_if_fail (rect != NULL);
13782
13783   rect->x = 0;
13784   rect->y = 0;
13785   rect->width = 0;
13786   rect->height = 0;
13787
13788   if (path)
13789     {
13790       /* Get vertical coords */
13791
13792       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
13793           tree == NULL)
13794         return;
13795
13796       rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13797       rect->height = gtk_tree_view_get_row_height (tree_view, node);
13798     }
13799
13800   if (column)
13801     {
13802       gint x2 = 0;
13803
13804       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
13805       rect->width = x2 - rect->x;
13806     }
13807 }
13808
13809 /**
13810  * gtk_tree_view_get_visible_rect:
13811  * @tree_view: a #GtkTreeView
13812  * @visible_rect: (out): rectangle to fill
13813  *
13814  * Fills @visible_rect with the currently-visible region of the
13815  * buffer, in tree coordinates. Convert to bin_window coordinates with
13816  * gtk_tree_view_convert_tree_to_bin_window_coords().
13817  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
13818  * scrollable area of the tree.
13819  **/
13820 void
13821 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
13822                                 GdkRectangle *visible_rect)
13823 {
13824   GtkAllocation allocation;
13825   GtkWidget *widget;
13826
13827   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13828
13829   widget = GTK_WIDGET (tree_view);
13830
13831   if (visible_rect)
13832     {
13833       gtk_widget_get_allocation (widget, &allocation);
13834       visible_rect->x = gtk_adjustment_get_value (tree_view->priv->hadjustment);
13835       visible_rect->y = gtk_adjustment_get_value (tree_view->priv->vadjustment);
13836       visible_rect->width = allocation.width;
13837       visible_rect->height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
13838     }
13839 }
13840
13841 /**
13842  * gtk_tree_view_convert_widget_to_tree_coords:
13843  * @tree_view: a #GtkTreeView
13844  * @wx: X coordinate relative to the widget
13845  * @wy: Y coordinate relative to the widget
13846  * @tx: (out): return location for tree X coordinate
13847  * @ty: (out): return location for tree Y coordinate
13848  *
13849  * Converts widget coordinates to coordinates for the
13850  * tree (the full scrollable area of the tree).
13851  *
13852  * Since: 2.12
13853  **/
13854 void
13855 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13856                                              gint         wx,
13857                                              gint         wy,
13858                                              gint        *tx,
13859                                              gint        *ty)
13860 {
13861   gint x, y;
13862
13863   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13864
13865   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13866                                                      wx, wy,
13867                                                      &x, &y);
13868   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13869                                                    x, y,
13870                                                    tx, ty);
13871 }
13872
13873 /**
13874  * gtk_tree_view_convert_tree_to_widget_coords:
13875  * @tree_view: a #GtkTreeView
13876  * @tx: X coordinate relative to the tree
13877  * @ty: Y coordinate relative to the tree
13878  * @wx: (out): return location for widget X coordinate
13879  * @wy: (out): return location for widget Y coordinate
13880  *
13881  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13882  * to widget coordinates.
13883  *
13884  * Since: 2.12
13885  **/
13886 void
13887 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13888                                              gint         tx,
13889                                              gint         ty,
13890                                              gint        *wx,
13891                                              gint        *wy)
13892 {
13893   gint x, y;
13894
13895   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13896
13897   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13898                                                    tx, ty,
13899                                                    &x, &y);
13900   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13901                                                      x, y,
13902                                                      wx, wy);
13903 }
13904
13905 /**
13906  * gtk_tree_view_convert_widget_to_bin_window_coords:
13907  * @tree_view: a #GtkTreeView
13908  * @wx: X coordinate relative to the widget
13909  * @wy: Y coordinate relative to the widget
13910  * @bx: (out): return location for bin_window X coordinate
13911  * @by: (out): return location for bin_window Y coordinate
13912  *
13913  * Converts widget coordinates to coordinates for the bin_window
13914  * (see gtk_tree_view_get_bin_window()).
13915  *
13916  * Since: 2.12
13917  **/
13918 void
13919 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13920                                                    gint         wx,
13921                                                    gint         wy,
13922                                                    gint        *bx,
13923                                                    gint        *by)
13924 {
13925   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13926
13927   if (bx)
13928     *bx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
13929   if (by)
13930     *by = wy - gtk_tree_view_get_effective_header_height (tree_view);
13931 }
13932
13933 /**
13934  * gtk_tree_view_convert_bin_window_to_widget_coords:
13935  * @tree_view: a #GtkTreeView
13936  * @bx: bin_window X coordinate
13937  * @by: bin_window Y coordinate
13938  * @wx: (out): return location for widget X coordinate
13939  * @wy: (out): return location for widget Y coordinate
13940  *
13941  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13942  * to widget relative coordinates.
13943  *
13944  * Since: 2.12
13945  **/
13946 void
13947 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13948                                                    gint         bx,
13949                                                    gint         by,
13950                                                    gint        *wx,
13951                                                    gint        *wy)
13952 {
13953   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13954
13955   if (wx)
13956     *wx = bx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
13957   if (wy)
13958     *wy = by + gtk_tree_view_get_effective_header_height (tree_view);
13959 }
13960
13961 /**
13962  * gtk_tree_view_convert_tree_to_bin_window_coords:
13963  * @tree_view: a #GtkTreeView
13964  * @tx: tree X coordinate
13965  * @ty: tree Y coordinate
13966  * @bx: (out): return location for X coordinate relative to bin_window
13967  * @by: (out): return location for Y coordinate relative to bin_window
13968  *
13969  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13970  * to bin_window coordinates.
13971  *
13972  * Since: 2.12
13973  **/
13974 void
13975 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13976                                                  gint         tx,
13977                                                  gint         ty,
13978                                                  gint        *bx,
13979                                                  gint        *by)
13980 {
13981   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13982
13983   if (bx)
13984     *bx = tx;
13985   if (by)
13986     *by = ty - tree_view->priv->dy;
13987 }
13988
13989 /**
13990  * gtk_tree_view_convert_bin_window_to_tree_coords:
13991  * @tree_view: a #GtkTreeView
13992  * @bx: X coordinate relative to bin_window
13993  * @by: Y coordinate relative to bin_window
13994  * @tx: (out): return location for tree X coordinate
13995  * @ty: (out): return location for tree Y coordinate
13996  *
13997  * Converts bin_window coordinates to coordinates for the
13998  * tree (the full scrollable area of the tree).
13999  *
14000  * Since: 2.12
14001  **/
14002 void
14003 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
14004                                                  gint         bx,
14005                                                  gint         by,
14006                                                  gint        *tx,
14007                                                  gint        *ty)
14008 {
14009   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14010
14011   if (tx)
14012     *tx = bx;
14013   if (ty)
14014     *ty = by + tree_view->priv->dy;
14015 }
14016
14017
14018
14019 /**
14020  * gtk_tree_view_get_visible_range:
14021  * @tree_view: A #GtkTreeView
14022  * @start_path: (out) (allow-none): Return location for start of region,
14023  *              or %NULL.
14024  * @end_path: (out) (allow-none): Return location for end of region, or %NULL.
14025  *
14026  * Sets @start_path and @end_path to be the first and last visible path.
14027  * Note that there may be invisible paths in between.
14028  *
14029  * The paths should be freed with gtk_tree_path_free() after use.
14030  *
14031  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
14032  *
14033  * Since: 2.8
14034  **/
14035 gboolean
14036 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
14037                                  GtkTreePath **start_path,
14038                                  GtkTreePath **end_path)
14039 {
14040   GtkRBTree *tree;
14041   GtkRBNode *node;
14042   gboolean retval;
14043
14044   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14045
14046   if (!tree_view->priv->tree)
14047     return FALSE;
14048
14049   retval = TRUE;
14050
14051   if (start_path)
14052     {
14053       _gtk_rbtree_find_offset (tree_view->priv->tree,
14054                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
14055                                &tree, &node);
14056       if (node)
14057         *start_path = _gtk_tree_path_new_from_rbtree (tree, node);
14058       else
14059         retval = FALSE;
14060     }
14061
14062   if (end_path)
14063     {
14064       gint y;
14065
14066       if (tree_view->priv->height < gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
14067         y = tree_view->priv->height - 1;
14068       else
14069         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1;
14070
14071       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
14072       if (node)
14073         *end_path = _gtk_tree_path_new_from_rbtree (tree, node);
14074       else
14075         retval = FALSE;
14076     }
14077
14078   return retval;
14079 }
14080
14081 /**
14082  * gtk_tree_view_is_blank_at_pos:
14083  * @tree_view: A #GtkTreeView
14084  * @x: The x position to be identified (relative to bin_window)
14085  * @y: The y position to be identified (relative to bin_window)
14086  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
14087  * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
14088  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
14089  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
14090  *
14091  * Determine whether the point (@x, @y) in @tree_view is blank, that is no
14092  * cell content nor an expander arrow is drawn at the location. If so, the
14093  * location can be considered as the background. You might wish to take
14094  * special action on clicks on the background, such as clearing a current
14095  * selection, having a custom context menu or starting rubber banding.
14096  *
14097  * The @x and @y coordinate that are provided must be relative to bin_window
14098  * coordinates.  That is, @x and @y must come from an event on @tree_view
14099  * where <literal>event->window == gtk_tree_view_get_bin_window (<!-- -->)</literal>.
14100  *
14101  * For converting widget coordinates (eg. the ones you get from
14102  * GtkWidget::query-tooltip), please see
14103  * gtk_tree_view_convert_widget_to_bin_window_coords().
14104  *
14105  * The @path, @column, @cell_x and @cell_y arguments will be filled in
14106  * likewise as for gtk_tree_view_get_path_at_pos().  Please see
14107  * gtk_tree_view_get_path_at_pos() for more information.
14108  *
14109  * Return value: %TRUE if the area at the given coordinates is blank,
14110  * %FALSE otherwise.
14111  *
14112  * Since: 3.0
14113  */
14114 gboolean
14115 gtk_tree_view_is_blank_at_pos (GtkTreeView       *tree_view,
14116                                gint                x,
14117                                gint                y,
14118                                GtkTreePath       **path,
14119                                GtkTreeViewColumn **column,
14120                                gint               *cell_x,
14121                                gint               *cell_y)
14122 {
14123   GtkRBTree *tree;
14124   GtkRBNode *node;
14125   GtkTreeIter iter;
14126   GtkTreePath *real_path;
14127   GtkTreeViewColumn *real_column;
14128   GdkRectangle cell_area, background_area;
14129
14130   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14131
14132   if (!gtk_tree_view_get_path_at_pos (tree_view, x, y,
14133                                       &real_path, &real_column,
14134                                       cell_x, cell_y))
14135     /* If there's no path here, it is blank */
14136     return TRUE;
14137
14138   if (path)
14139     *path = real_path;
14140
14141   if (column)
14142     *column = real_column;
14143
14144   gtk_tree_model_get_iter (tree_view->priv->model, &iter, real_path);
14145   _gtk_tree_view_find_node (tree_view, real_path, &tree, &node);
14146
14147   /* Check if there's an expander arrow at (x, y) */
14148   if (real_column == tree_view->priv->expander_column
14149       && gtk_tree_view_draw_expanders (tree_view))
14150     {
14151       gboolean over_arrow;
14152
14153       over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
14154
14155       if (over_arrow)
14156         {
14157           if (!path)
14158             gtk_tree_path_free (real_path);
14159           return FALSE;
14160         }
14161     }
14162
14163   /* Otherwise, have the column see if there's a cell at (x, y) */
14164   gtk_tree_view_column_cell_set_cell_data (real_column,
14165                                            tree_view->priv->model,
14166                                            &iter,
14167                                            GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14168                                            node->children ? TRUE : FALSE);
14169
14170   gtk_tree_view_get_background_area (tree_view, real_path, real_column,
14171                                      &background_area);
14172   gtk_tree_view_get_cell_area (tree_view, real_path, real_column,
14173                                &cell_area);
14174
14175   if (!path)
14176     gtk_tree_path_free (real_path);
14177
14178   return _gtk_tree_view_column_is_blank_at_pos (real_column,
14179                                                 &cell_area,
14180                                                 &background_area,
14181                                                 x, y);
14182 }
14183
14184 static void
14185 unset_reorderable (GtkTreeView *tree_view)
14186 {
14187   if (tree_view->priv->reorderable)
14188     {
14189       tree_view->priv->reorderable = FALSE;
14190       g_object_notify (G_OBJECT (tree_view), "reorderable");
14191     }
14192 }
14193
14194 /**
14195  * gtk_tree_view_enable_model_drag_source:
14196  * @tree_view: a #GtkTreeView
14197  * @start_button_mask: Mask of allowed buttons to start drag
14198  * @targets: (array length=n_targets): the table of targets that the drag will support
14199  * @n_targets: the number of items in @targets
14200  * @actions: the bitmask of possible actions for a drag from this
14201  *    widget
14202  *
14203  * Turns @tree_view into a drag source for automatic DND. Calling this
14204  * method sets #GtkTreeView:reorderable to %FALSE.
14205  **/
14206 void
14207 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
14208                                         GdkModifierType           start_button_mask,
14209                                         const GtkTargetEntry     *targets,
14210                                         gint                      n_targets,
14211                                         GdkDragAction             actions)
14212 {
14213   TreeViewDragInfo *di;
14214
14215   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14216
14217   gtk_drag_source_set (GTK_WIDGET (tree_view),
14218                        0,
14219                        targets,
14220                        n_targets,
14221                        actions);
14222
14223   di = ensure_info (tree_view);
14224
14225   di->start_button_mask = start_button_mask;
14226   di->source_actions = actions;
14227   di->source_set = TRUE;
14228
14229   unset_reorderable (tree_view);
14230 }
14231
14232 /**
14233  * gtk_tree_view_enable_model_drag_dest:
14234  * @tree_view: a #GtkTreeView
14235  * @targets: (array length=n_targets): the table of targets that
14236  *           the drag will support
14237  * @n_targets: the number of items in @targets
14238  * @actions: the bitmask of possible actions for a drag from this
14239  *    widget
14240  *
14241  * Turns @tree_view into a drop destination for automatic DND. Calling
14242  * this method sets #GtkTreeView:reorderable to %FALSE.
14243  **/
14244 void
14245 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
14246                                       const GtkTargetEntry     *targets,
14247                                       gint                      n_targets,
14248                                       GdkDragAction             actions)
14249 {
14250   TreeViewDragInfo *di;
14251
14252   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14253
14254   gtk_drag_dest_set (GTK_WIDGET (tree_view),
14255                      0,
14256                      targets,
14257                      n_targets,
14258                      actions);
14259
14260   di = ensure_info (tree_view);
14261   di->dest_set = TRUE;
14262
14263   unset_reorderable (tree_view);
14264 }
14265
14266 /**
14267  * gtk_tree_view_unset_rows_drag_source:
14268  * @tree_view: a #GtkTreeView
14269  *
14270  * Undoes the effect of
14271  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
14272  * #GtkTreeView:reorderable to %FALSE.
14273  **/
14274 void
14275 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
14276 {
14277   TreeViewDragInfo *di;
14278
14279   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14280
14281   di = get_info (tree_view);
14282
14283   if (di)
14284     {
14285       if (di->source_set)
14286         {
14287           gtk_drag_source_unset (GTK_WIDGET (tree_view));
14288           di->source_set = FALSE;
14289         }
14290
14291       if (!di->dest_set && !di->source_set)
14292         remove_info (tree_view);
14293     }
14294
14295   unset_reorderable (tree_view);
14296 }
14297
14298 /**
14299  * gtk_tree_view_unset_rows_drag_dest:
14300  * @tree_view: a #GtkTreeView
14301  *
14302  * Undoes the effect of
14303  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
14304  * #GtkTreeView:reorderable to %FALSE.
14305  **/
14306 void
14307 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
14308 {
14309   TreeViewDragInfo *di;
14310
14311   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14312
14313   di = get_info (tree_view);
14314
14315   if (di)
14316     {
14317       if (di->dest_set)
14318         {
14319           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
14320           di->dest_set = FALSE;
14321         }
14322
14323       if (!di->dest_set && !di->source_set)
14324         remove_info (tree_view);
14325     }
14326
14327   unset_reorderable (tree_view);
14328 }
14329
14330 /**
14331  * gtk_tree_view_set_drag_dest_row:
14332  * @tree_view: a #GtkTreeView
14333  * @path: (allow-none): The path of the row to highlight, or %NULL
14334  * @pos: Specifies whether to drop before, after or into the row
14335  *
14336  * Sets the row that is highlighted for feedback.
14337  * If @path is %NULL, an existing highlight is removed.
14338  */
14339 void
14340 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
14341                                  GtkTreePath            *path,
14342                                  GtkTreeViewDropPosition pos)
14343 {
14344   GtkTreePath *current_dest;
14345
14346   /* Note; this function is exported to allow a custom DND
14347    * implementation, so it can't touch TreeViewDragInfo
14348    */
14349
14350   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14351
14352   current_dest = NULL;
14353
14354   if (tree_view->priv->drag_dest_row)
14355     {
14356       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14357       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
14358     }
14359
14360   /* special case a drop on an empty model */
14361   tree_view->priv->empty_view_drop = 0;
14362
14363   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
14364       && gtk_tree_path_get_depth (path) == 1
14365       && gtk_tree_path_get_indices (path)[0] == 0)
14366     {
14367       gint n_children;
14368
14369       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
14370                                                    NULL);
14371
14372       if (!n_children)
14373         tree_view->priv->empty_view_drop = 1;
14374     }
14375
14376   tree_view->priv->drag_dest_pos = pos;
14377
14378   if (path)
14379     {
14380       tree_view->priv->drag_dest_row =
14381         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
14382       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
14383     }
14384   else
14385     tree_view->priv->drag_dest_row = NULL;
14386
14387   if (current_dest)
14388     {
14389       GtkRBTree *tree, *new_tree;
14390       GtkRBNode *node, *new_node;
14391
14392       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
14393       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
14394
14395       if (tree && node)
14396         {
14397           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
14398           if (new_tree && new_node)
14399             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14400
14401           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
14402           if (new_tree && new_node)
14403             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14404         }
14405       gtk_tree_path_free (current_dest);
14406     }
14407 }
14408
14409 /**
14410  * gtk_tree_view_get_drag_dest_row:
14411  * @tree_view: a #GtkTreeView
14412  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14413  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14414  *
14415  * Gets information about the row that is highlighted for feedback.
14416  **/
14417 void
14418 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
14419                                  GtkTreePath             **path,
14420                                  GtkTreeViewDropPosition  *pos)
14421 {
14422   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14423
14424   if (path)
14425     {
14426       if (tree_view->priv->drag_dest_row)
14427         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14428       else
14429         {
14430           if (tree_view->priv->empty_view_drop)
14431             *path = gtk_tree_path_new_from_indices (0, -1);
14432           else
14433             *path = NULL;
14434         }
14435     }
14436
14437   if (pos)
14438     *pos = tree_view->priv->drag_dest_pos;
14439 }
14440
14441 /**
14442  * gtk_tree_view_get_dest_row_at_pos:
14443  * @tree_view: a #GtkTreeView
14444  * @drag_x: the position to determine the destination row for
14445  * @drag_y: the position to determine the destination row for
14446  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14447  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14448  *
14449  * Determines the destination row for a given position.  @drag_x and
14450  * @drag_y are expected to be in widget coordinates.  This function is only
14451  * meaningful if @tree_view is realized.  Therefore this function will always
14452  * return %FALSE if @tree_view is not realized or does not have a model.
14453  *
14454  * Return value: whether there is a row at the given position, %TRUE if this
14455  * is indeed the case.
14456  **/
14457 gboolean
14458 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
14459                                    gint                     drag_x,
14460                                    gint                     drag_y,
14461                                    GtkTreePath            **path,
14462                                    GtkTreeViewDropPosition *pos)
14463 {
14464   gint cell_y;
14465   gint bin_x, bin_y;
14466   gdouble offset_into_row;
14467   gdouble third;
14468   GdkRectangle cell;
14469   GtkTreeViewColumn *column = NULL;
14470   GtkTreePath *tmp_path = NULL;
14471
14472   /* Note; this function is exported to allow a custom DND
14473    * implementation, so it can't touch TreeViewDragInfo
14474    */
14475
14476   g_return_val_if_fail (tree_view != NULL, FALSE);
14477   g_return_val_if_fail (drag_x >= 0, FALSE);
14478   g_return_val_if_fail (drag_y >= 0, FALSE);
14479
14480   if (path)
14481     *path = NULL;
14482
14483   if (tree_view->priv->bin_window == NULL)
14484     return FALSE;
14485
14486   if (tree_view->priv->tree == NULL)
14487     return FALSE;
14488
14489   /* If in the top third of a row, we drop before that row; if
14490    * in the bottom third, drop after that row; if in the middle,
14491    * and the row has children, drop into the row.
14492    */
14493   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
14494                                                      &bin_x, &bin_y);
14495
14496   if (!gtk_tree_view_get_path_at_pos (tree_view,
14497                                       bin_x,
14498                                       bin_y,
14499                                       &tmp_path,
14500                                       &column,
14501                                       NULL,
14502                                       &cell_y))
14503     return FALSE;
14504
14505   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
14506                                      &cell);
14507
14508   offset_into_row = cell_y;
14509
14510   if (path)
14511     *path = tmp_path;
14512   else
14513     gtk_tree_path_free (tmp_path);
14514
14515   tmp_path = NULL;
14516
14517   third = cell.height / 3.0;
14518
14519   if (pos)
14520     {
14521       if (offset_into_row < third)
14522         {
14523           *pos = GTK_TREE_VIEW_DROP_BEFORE;
14524         }
14525       else if (offset_into_row < (cell.height / 2.0))
14526         {
14527           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
14528         }
14529       else if (offset_into_row < third * 2.0)
14530         {
14531           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
14532         }
14533       else
14534         {
14535           *pos = GTK_TREE_VIEW_DROP_AFTER;
14536         }
14537     }
14538
14539   return TRUE;
14540 }
14541
14542
14543
14544 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
14545 /**
14546  * gtk_tree_view_create_row_drag_icon:
14547  * @tree_view: a #GtkTreeView
14548  * @path: a #GtkTreePath in @tree_view
14549  *
14550  * Creates a #cairo_surface_t representation of the row at @path.
14551  * This image is used for a drag icon.
14552  *
14553  * Return value: (transfer full): a newly-allocated surface of the drag icon.
14554  **/
14555 cairo_surface_t *
14556 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
14557                                     GtkTreePath  *path)
14558 {
14559   GtkTreeIter   iter;
14560   GtkRBTree    *tree;
14561   GtkRBNode    *node;
14562   GtkStyleContext *context;
14563   gint cell_offset;
14564   GList *list;
14565   GdkRectangle background_area;
14566   GtkWidget *widget;
14567   gint depth;
14568   /* start drawing inside the black outline */
14569   gint x = 1, y = 1;
14570   cairo_surface_t *surface;
14571   gint bin_window_width;
14572   gboolean is_separator = FALSE;
14573   gboolean rtl, allow_rules;
14574   cairo_t *cr;
14575
14576   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14577   g_return_val_if_fail (path != NULL, NULL);
14578
14579   widget = GTK_WIDGET (tree_view);
14580
14581   if (!gtk_widget_get_realized (widget))
14582     return NULL;
14583
14584   depth = gtk_tree_path_get_depth (path);
14585
14586   _gtk_tree_view_find_node (tree_view,
14587                             path,
14588                             &tree,
14589                             &node);
14590
14591   if (tree == NULL)
14592     return NULL;
14593
14594   if (!gtk_tree_model_get_iter (tree_view->priv->model,
14595                                 &iter,
14596                                 path))
14597     return NULL;
14598
14599   context = gtk_widget_get_style_context (widget);
14600
14601   gtk_style_context_save (context);
14602
14603   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
14604   gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0);
14605
14606   gtk_widget_style_get (widget,
14607                         "allow-rules", &allow_rules,
14608                         NULL);
14609
14610   if (allow_rules && tree_view->priv->has_rules)
14611     {
14612       GtkRegionFlags row_flags;
14613
14614       if ((_gtk_rbtree_node_get_index (tree, node) % 2))
14615         row_flags = GTK_REGION_ODD;
14616       else
14617         row_flags = GTK_REGION_EVEN;
14618
14619       gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
14620     }
14621
14622   is_separator = row_is_separator (tree_view, &iter, NULL);
14623
14624   cell_offset = x;
14625
14626   background_area.y = y;
14627   background_area.height = gtk_tree_view_get_row_height (tree_view, node);
14628
14629   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
14630
14631   surface = gdk_window_create_similar_surface (tree_view->priv->bin_window,
14632                                                CAIRO_CONTENT_COLOR,
14633                                                bin_window_width + 2,
14634                                                background_area.height + 2);
14635
14636   cr = cairo_create (surface);
14637
14638   gtk_render_background (context, cr, 0, 0,
14639                          bin_window_width + 2,
14640                          background_area.height + 2);
14641
14642   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
14643
14644   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
14645       list;
14646       list = (rtl ? list->prev : list->next))
14647     {
14648       GtkTreeViewColumn *column = list->data;
14649       GdkRectangle cell_area;
14650       gint vertical_separator;
14651
14652       if (!gtk_tree_view_column_get_visible (column))
14653         continue;
14654
14655       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
14656                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14657                                                node->children?TRUE:FALSE);
14658
14659       background_area.x = cell_offset;
14660       background_area.width = gtk_tree_view_column_get_width (column);
14661
14662       gtk_widget_style_get (widget,
14663                             "vertical-separator", &vertical_separator,
14664                             NULL);
14665
14666       cell_area = background_area;
14667
14668       cell_area.y += vertical_separator / 2;
14669       cell_area.height -= vertical_separator;
14670
14671       if (gtk_tree_view_is_expander_column (tree_view, column))
14672         {
14673           if (!rtl)
14674             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
14675           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
14676
14677           if (gtk_tree_view_draw_expanders (tree_view))
14678             {
14679               if (!rtl)
14680                 cell_area.x += depth * tree_view->priv->expander_size;
14681               cell_area.width -= depth * tree_view->priv->expander_size;
14682             }
14683         }
14684
14685       if (gtk_tree_view_column_cell_is_visible (column))
14686         {
14687           if (is_separator)
14688             {
14689               gtk_style_context_save (context);
14690               gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
14691
14692               gtk_render_line (context, cr,
14693                                cell_area.x,
14694                                cell_area.y + cell_area.height / 2,
14695                                cell_area.x + cell_area.width,
14696                                cell_area.y + cell_area.height / 2);
14697
14698               gtk_style_context_restore (context);
14699             }
14700           else
14701             {
14702               _gtk_tree_view_column_cell_render (column,
14703                                                  cr,
14704                                                  &background_area,
14705                                                  &cell_area,
14706                                                  0, FALSE);
14707             }
14708         }
14709       cell_offset += gtk_tree_view_column_get_width (column);
14710     }
14711
14712   cairo_set_source_rgb (cr, 0, 0, 0);
14713   cairo_rectangle (cr,
14714                    0.5, 0.5,
14715                    bin_window_width + 1,
14716                    background_area.height + 1);
14717   cairo_set_line_width (cr, 1.0);
14718   cairo_stroke (cr);
14719
14720   cairo_destroy (cr);
14721
14722   cairo_surface_set_device_offset (surface, 2, 2);
14723
14724   gtk_style_context_restore (context);
14725
14726   return surface;
14727 }
14728
14729
14730 /**
14731  * gtk_tree_view_set_destroy_count_func:
14732  * @tree_view: A #GtkTreeView
14733  * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
14734  * @data: (allow-none): User data to be passed to @func, or %NULL
14735  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14736  *
14737  * This function should almost never be used.  It is meant for private use by
14738  * ATK for determining the number of visible children that are removed when the
14739  * user collapses a row, or a row is deleted.
14740  *
14741  * Deprecated: 3.4: Accessibility does not need the function anymore.
14742  **/
14743 void
14744 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
14745                                       GtkTreeDestroyCountFunc  func,
14746                                       gpointer                 data,
14747                                       GDestroyNotify           destroy)
14748 {
14749   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14750
14751   if (tree_view->priv->destroy_count_destroy)
14752     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
14753
14754   tree_view->priv->destroy_count_func = func;
14755   tree_view->priv->destroy_count_data = data;
14756   tree_view->priv->destroy_count_destroy = destroy;
14757 }
14758
14759
14760 /*
14761  * Interactive search
14762  */
14763
14764 /**
14765  * gtk_tree_view_set_enable_search:
14766  * @tree_view: A #GtkTreeView
14767  * @enable_search: %TRUE, if the user can search interactively
14768  *
14769  * If @enable_search is set, then the user can type in text to search through
14770  * the tree interactively (this is sometimes called "typeahead find").
14771  *
14772  * Note that even if this is %FALSE, the user can still initiate a search
14773  * using the "start-interactive-search" key binding.
14774  */
14775 void
14776 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
14777                                  gboolean     enable_search)
14778 {
14779   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14780
14781   enable_search = !!enable_search;
14782
14783   if (tree_view->priv->enable_search != enable_search)
14784     {
14785        tree_view->priv->enable_search = enable_search;
14786        g_object_notify (G_OBJECT (tree_view), "enable-search");
14787     }
14788 }
14789
14790 /**
14791  * gtk_tree_view_get_enable_search:
14792  * @tree_view: A #GtkTreeView
14793  *
14794  * Returns whether or not the tree allows to start interactive searching
14795  * by typing in text.
14796  *
14797  * Return value: whether or not to let the user search interactively
14798  */
14799 gboolean
14800 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
14801 {
14802   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14803
14804   return tree_view->priv->enable_search;
14805 }
14806
14807
14808 /**
14809  * gtk_tree_view_get_search_column:
14810  * @tree_view: A #GtkTreeView
14811  *
14812  * Gets the column searched on by the interactive search code.
14813  *
14814  * Return value: the column the interactive search code searches in.
14815  */
14816 gint
14817 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
14818 {
14819   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
14820
14821   return (tree_view->priv->search_column);
14822 }
14823
14824 /**
14825  * gtk_tree_view_set_search_column:
14826  * @tree_view: A #GtkTreeView
14827  * @column: the column of the model to search in, or -1 to disable searching
14828  *
14829  * Sets @column as the column where the interactive search code should
14830  * search in for the current model.
14831  *
14832  * If the search column is set, users can use the "start-interactive-search"
14833  * key binding to bring up search popup. The enable-search property controls
14834  * whether simply typing text will also start an interactive search.
14835  *
14836  * Note that @column refers to a column of the current model. The search
14837  * column is reset to -1 when the model is changed.
14838  */
14839 void
14840 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
14841                                  gint         column)
14842 {
14843   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14844   g_return_if_fail (column >= -1);
14845
14846   if (tree_view->priv->search_column == column)
14847     return;
14848
14849   tree_view->priv->search_column = column;
14850   g_object_notify (G_OBJECT (tree_view), "search-column");
14851 }
14852
14853 /**
14854  * gtk_tree_view_get_search_equal_func: (skip)
14855  * @tree_view: A #GtkTreeView
14856  *
14857  * Returns the compare function currently in use.
14858  *
14859  * Return value: the currently used compare function for the search code.
14860  */
14861
14862 GtkTreeViewSearchEqualFunc
14863 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
14864 {
14865   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14866
14867   return tree_view->priv->search_equal_func;
14868 }
14869
14870 /**
14871  * gtk_tree_view_set_search_equal_func:
14872  * @tree_view: A #GtkTreeView
14873  * @search_equal_func: the compare function to use during the search
14874  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
14875  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
14876  *
14877  * Sets the compare function for the interactive search capabilities; note
14878  * that somewhat like strcmp() returning 0 for equality
14879  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
14880  **/
14881 void
14882 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14883                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14884                                      gpointer                    search_user_data,
14885                                      GDestroyNotify              search_destroy)
14886 {
14887   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14888   g_return_if_fail (search_equal_func != NULL);
14889
14890   if (tree_view->priv->search_destroy)
14891     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14892
14893   tree_view->priv->search_equal_func = search_equal_func;
14894   tree_view->priv->search_user_data = search_user_data;
14895   tree_view->priv->search_destroy = search_destroy;
14896   if (tree_view->priv->search_equal_func == NULL)
14897     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14898 }
14899
14900 /**
14901  * gtk_tree_view_get_search_entry:
14902  * @tree_view: A #GtkTreeView
14903  *
14904  * Returns the #GtkEntry which is currently in use as interactive search
14905  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14906  * will be returned.
14907  *
14908  * Return value: (transfer none): the entry currently in use as search entry.
14909  *
14910  * Since: 2.10
14911  */
14912 GtkEntry *
14913 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14914 {
14915   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14916
14917   if (tree_view->priv->search_custom_entry_set)
14918     return GTK_ENTRY (tree_view->priv->search_entry);
14919
14920   return NULL;
14921 }
14922
14923 /**
14924  * gtk_tree_view_set_search_entry:
14925  * @tree_view: A #GtkTreeView
14926  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
14927  *
14928  * Sets the entry which the interactive search code will use for this
14929  * @tree_view.  This is useful when you want to provide a search entry
14930  * in our interface at all time at a fixed position.  Passing %NULL for
14931  * @entry will make the interactive search code use the built-in popup
14932  * entry again.
14933  *
14934  * Since: 2.10
14935  */
14936 void
14937 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14938                                 GtkEntry    *entry)
14939 {
14940   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14941   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14942
14943   if (tree_view->priv->search_custom_entry_set)
14944     {
14945       if (tree_view->priv->search_entry_changed_id)
14946         {
14947           g_signal_handler_disconnect (tree_view->priv->search_entry,
14948                                        tree_view->priv->search_entry_changed_id);
14949           tree_view->priv->search_entry_changed_id = 0;
14950         }
14951       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14952                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14953                                             tree_view);
14954
14955       g_object_unref (tree_view->priv->search_entry);
14956     }
14957   else if (tree_view->priv->search_window)
14958     {
14959       gtk_widget_destroy (tree_view->priv->search_window);
14960
14961       tree_view->priv->search_window = NULL;
14962     }
14963
14964   if (entry)
14965     {
14966       tree_view->priv->search_entry = g_object_ref (entry);
14967       tree_view->priv->search_custom_entry_set = TRUE;
14968
14969       if (tree_view->priv->search_entry_changed_id == 0)
14970         {
14971           tree_view->priv->search_entry_changed_id =
14972             g_signal_connect (tree_view->priv->search_entry, "changed",
14973                               G_CALLBACK (gtk_tree_view_search_init),
14974                               tree_view);
14975         }
14976
14977         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14978                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14979                           tree_view);
14980
14981         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14982     }
14983   else
14984     {
14985       tree_view->priv->search_entry = NULL;
14986       tree_view->priv->search_custom_entry_set = FALSE;
14987     }
14988 }
14989
14990 /**
14991  * gtk_tree_view_set_search_position_func:
14992  * @tree_view: A #GtkTreeView
14993  * @func: (allow-none): the function to use to position the search dialog, or %NULL
14994  *    to use the default search position function
14995  * @data: (allow-none): user data to pass to @func, or %NULL
14996  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14997  *
14998  * Sets the function to use when positioning the search dialog.
14999  *
15000  * Since: 2.10
15001  **/
15002 void
15003 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
15004                                         GtkTreeViewSearchPositionFunc  func,
15005                                         gpointer                       user_data,
15006                                         GDestroyNotify                 destroy)
15007 {
15008   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15009
15010   if (tree_view->priv->search_position_destroy)
15011     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
15012
15013   tree_view->priv->search_position_func = func;
15014   tree_view->priv->search_position_user_data = user_data;
15015   tree_view->priv->search_position_destroy = destroy;
15016   if (tree_view->priv->search_position_func == NULL)
15017     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
15018 }
15019
15020 /**
15021  * gtk_tree_view_get_search_position_func: (skip)
15022  * @tree_view: A #GtkTreeView
15023  *
15024  * Returns the positioning function currently in use.
15025  *
15026  * Return value: the currently used function for positioning the search dialog.
15027  *
15028  * Since: 2.10
15029  */
15030 GtkTreeViewSearchPositionFunc
15031 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
15032 {
15033   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15034
15035   return tree_view->priv->search_position_func;
15036 }
15037
15038
15039 static void
15040 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
15041                                   GtkTreeView *tree_view,
15042                                   GdkDevice   *device)
15043 {
15044   if (tree_view->priv->disable_popdown)
15045     return;
15046
15047   if (tree_view->priv->search_entry_changed_id)
15048     {
15049       g_signal_handler_disconnect (tree_view->priv->search_entry,
15050                                    tree_view->priv->search_entry_changed_id);
15051       tree_view->priv->search_entry_changed_id = 0;
15052     }
15053   if (tree_view->priv->typeselect_flush_timeout)
15054     {
15055       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15056       tree_view->priv->typeselect_flush_timeout = 0;
15057     }
15058
15059   if (gtk_widget_get_visible (search_dialog))
15060     {
15061       /* send focus-in event */
15062       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
15063       gtk_widget_hide (search_dialog);
15064       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
15065       send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
15066     }
15067 }
15068
15069 static void
15070 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
15071                                     GtkWidget   *search_dialog,
15072                                     gpointer     user_data)
15073 {
15074   gint x, y;
15075   gint tree_x, tree_y;
15076   gint tree_width, tree_height;
15077   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
15078   GdkScreen *screen = gdk_window_get_screen (tree_window);
15079   GtkRequisition requisition;
15080   gint monitor_num;
15081   GdkRectangle monitor;
15082
15083   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
15084   gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
15085
15086   gtk_widget_realize (search_dialog);
15087
15088   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
15089   tree_width = gdk_window_get_width (tree_window);
15090   tree_height = gdk_window_get_height (tree_window);
15091   gtk_widget_get_preferred_size (search_dialog, &requisition, NULL);
15092
15093   if (tree_x + tree_width > gdk_screen_get_width (screen))
15094     x = gdk_screen_get_width (screen) - requisition.width;
15095   else if (tree_x + tree_width - requisition.width < 0)
15096     x = 0;
15097   else
15098     x = tree_x + tree_width - requisition.width;
15099
15100   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
15101     y = gdk_screen_get_height (screen) - requisition.height;
15102   else if (tree_y + tree_height < 0) /* isn't really possible ... */
15103     y = 0;
15104   else
15105     y = tree_y + tree_height;
15106
15107   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
15108 }
15109
15110 static void
15111 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
15112                                       GtkMenu  *menu,
15113                                       gpointer  data)
15114 {
15115   GtkTreeView *tree_view = (GtkTreeView *)data;
15116
15117   tree_view->priv->disable_popdown = 1;
15118   g_signal_connect (menu, "hide",
15119                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
15120 }
15121
15122 /* Because we're visible but offscreen, we just set a flag in the preedit
15123  * callback.
15124  */
15125 static void
15126 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
15127                                       GtkTreeView  *tree_view)
15128 {
15129   tree_view->priv->imcontext_changed = 1;
15130   if (tree_view->priv->typeselect_flush_timeout)
15131     {
15132       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15133       tree_view->priv->typeselect_flush_timeout =
15134         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15135                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15136                        tree_view);
15137     }
15138
15139 }
15140
15141 static void
15142 gtk_tree_view_search_activate (GtkEntry    *entry,
15143                                GtkTreeView *tree_view)
15144 {
15145   GtkTreePath *path;
15146
15147   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
15148                                     tree_view,
15149                                     gtk_get_current_event_device ());
15150
15151   /* If we have a row selected and it's the cursor row, we activate
15152    * the row XXX */
15153   if (tree_view->priv->cursor_node &&
15154       GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
15155     {
15156       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
15157                                              tree_view->priv->cursor_node);
15158
15159       gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
15160
15161       gtk_tree_path_free (path);
15162     }
15163 }
15164
15165 static gboolean
15166 gtk_tree_view_real_search_enable_popdown (gpointer data)
15167 {
15168   GtkTreeView *tree_view = (GtkTreeView *)data;
15169
15170   tree_view->priv->disable_popdown = 0;
15171
15172   return FALSE;
15173 }
15174
15175 static void
15176 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
15177                                      gpointer   data)
15178 {
15179   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
15180 }
15181
15182 static gboolean
15183 gtk_tree_view_search_delete_event (GtkWidget *widget,
15184                                    GdkEventAny *event,
15185                                    GtkTreeView *tree_view)
15186 {
15187   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15188
15189   gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
15190
15191   return TRUE;
15192 }
15193
15194 static gboolean
15195 gtk_tree_view_search_button_press_event (GtkWidget *widget,
15196                                          GdkEventButton *event,
15197                                          GtkTreeView *tree_view)
15198 {
15199   GdkDevice *keyb_device;
15200
15201   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15202
15203   keyb_device = gdk_device_get_associated_device (event->device);
15204   gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
15205
15206   if (event->window == tree_view->priv->bin_window)
15207     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
15208
15209   return TRUE;
15210 }
15211
15212 static gboolean
15213 gtk_tree_view_search_scroll_event (GtkWidget *widget,
15214                                    GdkEventScroll *event,
15215                                    GtkTreeView *tree_view)
15216 {
15217   gboolean retval = FALSE;
15218
15219   if (event->direction == GDK_SCROLL_UP)
15220     {
15221       gtk_tree_view_search_move (widget, tree_view, TRUE);
15222       retval = TRUE;
15223     }
15224   else if (event->direction == GDK_SCROLL_DOWN)
15225     {
15226       gtk_tree_view_search_move (widget, tree_view, FALSE);
15227       retval = TRUE;
15228     }
15229
15230   /* renew the flush timeout */
15231   if (retval && tree_view->priv->typeselect_flush_timeout
15232       && !tree_view->priv->search_custom_entry_set)
15233     {
15234       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15235       tree_view->priv->typeselect_flush_timeout =
15236         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15237                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15238                        tree_view);
15239     }
15240
15241   return retval;
15242 }
15243
15244 static gboolean
15245 gtk_tree_view_search_key_press_event (GtkWidget *widget,
15246                                       GdkEventKey *event,
15247                                       GtkTreeView *tree_view)
15248 {
15249   GdkModifierType default_accel;
15250   gboolean        retval = FALSE;
15251
15252   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15253   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15254
15255   /* close window and cancel the search */
15256   if (!tree_view->priv->search_custom_entry_set
15257       && (event->keyval == GDK_KEY_Escape ||
15258           event->keyval == GDK_KEY_Tab ||
15259             event->keyval == GDK_KEY_KP_Tab ||
15260             event->keyval == GDK_KEY_ISO_Left_Tab))
15261     {
15262       gtk_tree_view_search_dialog_hide (widget, tree_view,
15263                                         gdk_event_get_device ((GdkEvent *) event));
15264       return TRUE;
15265     }
15266
15267   default_accel = gtk_widget_get_modifier_mask (widget,
15268                                                 GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
15269
15270   /* select previous matching iter */
15271   if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
15272     {
15273       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15274         gtk_widget_error_bell (widget);
15275
15276       retval = TRUE;
15277     }
15278
15279   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == (default_accel | GDK_SHIFT_MASK))
15280       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15281     {
15282       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15283         gtk_widget_error_bell (widget);
15284
15285       retval = TRUE;
15286     }
15287
15288   /* select next matching iter */
15289   if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
15290     {
15291       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15292         gtk_widget_error_bell (widget);
15293
15294       retval = TRUE;
15295     }
15296
15297   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == default_accel)
15298       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15299     {
15300       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15301         gtk_widget_error_bell (widget);
15302
15303       retval = TRUE;
15304     }
15305
15306   /* renew the flush timeout */
15307   if (retval && tree_view->priv->typeselect_flush_timeout
15308       && !tree_view->priv->search_custom_entry_set)
15309     {
15310       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15311       tree_view->priv->typeselect_flush_timeout =
15312         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15313                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15314                        tree_view);
15315     }
15316
15317   return retval;
15318 }
15319
15320 /*  this function returns FALSE if there is a search string but
15321  *  nothing was found, and TRUE otherwise.
15322  */
15323 static gboolean
15324 gtk_tree_view_search_move (GtkWidget   *window,
15325                            GtkTreeView *tree_view,
15326                            gboolean     up)
15327 {
15328   gboolean ret;
15329   gint len;
15330   gint count = 0;
15331   const gchar *text;
15332   GtkTreeIter iter;
15333   GtkTreeModel *model;
15334   GtkTreeSelection *selection;
15335
15336   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
15337
15338   g_return_val_if_fail (text != NULL, FALSE);
15339
15340   len = strlen (text);
15341
15342   if (up && tree_view->priv->selected_iter == 1)
15343     return strlen (text) < 1;
15344
15345   len = strlen (text);
15346
15347   if (len < 1)
15348     return TRUE;
15349
15350   model = gtk_tree_view_get_model (tree_view);
15351   selection = gtk_tree_view_get_selection (tree_view);
15352
15353   /* search */
15354   gtk_tree_selection_unselect_all (selection);
15355   if (!gtk_tree_model_get_iter_first (model, &iter))
15356     return TRUE;
15357
15358   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
15359                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
15360
15361   if (ret)
15362     {
15363       /* found */
15364       tree_view->priv->selected_iter += up?(-1):(1);
15365       return TRUE;
15366     }
15367   else
15368     {
15369       /* return to old iter */
15370       count = 0;
15371       gtk_tree_model_get_iter_first (model, &iter);
15372       gtk_tree_view_search_iter (model, selection,
15373                                  &iter, text,
15374                                  &count, tree_view->priv->selected_iter);
15375       return FALSE;
15376     }
15377 }
15378
15379 static gboolean
15380 gtk_tree_view_search_equal_func (GtkTreeModel *model,
15381                                  gint          column,
15382                                  const gchar  *key,
15383                                  GtkTreeIter  *iter,
15384                                  gpointer      search_data)
15385 {
15386   gboolean retval = TRUE;
15387   const gchar *str;
15388   gchar *normalized_string;
15389   gchar *normalized_key;
15390   gchar *case_normalized_string = NULL;
15391   gchar *case_normalized_key = NULL;
15392   GValue value = G_VALUE_INIT;
15393   GValue transformed = G_VALUE_INIT;
15394
15395   gtk_tree_model_get_value (model, iter, column, &value);
15396
15397   g_value_init (&transformed, G_TYPE_STRING);
15398
15399   if (!g_value_transform (&value, &transformed))
15400     {
15401       g_value_unset (&value);
15402       return TRUE;
15403     }
15404
15405   g_value_unset (&value);
15406
15407   str = g_value_get_string (&transformed);
15408   if (!str)
15409     {
15410       g_value_unset (&transformed);
15411       return TRUE;
15412     }
15413
15414   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
15415   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
15416
15417   if (normalized_string && normalized_key)
15418     {
15419       case_normalized_string = g_utf8_casefold (normalized_string, -1);
15420       case_normalized_key = g_utf8_casefold (normalized_key, -1);
15421
15422       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
15423         retval = FALSE;
15424     }
15425
15426   g_value_unset (&transformed);
15427   g_free (normalized_key);
15428   g_free (normalized_string);
15429   g_free (case_normalized_key);
15430   g_free (case_normalized_string);
15431
15432   return retval;
15433 }
15434
15435 static gboolean
15436 gtk_tree_view_search_iter (GtkTreeModel     *model,
15437                            GtkTreeSelection *selection,
15438                            GtkTreeIter      *iter,
15439                            const gchar      *text,
15440                            gint             *count,
15441                            gint              n)
15442 {
15443   GtkRBTree *tree = NULL;
15444   GtkRBNode *node = NULL;
15445   GtkTreePath *path;
15446
15447   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
15448
15449   path = gtk_tree_model_get_path (model, iter);
15450   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15451
15452   do
15453     {
15454       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
15455         {
15456           (*count)++;
15457           if (*count == n)
15458             {
15459               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
15460                                             TRUE, 0.5, 0.0);
15461               gtk_tree_selection_select_iter (selection, iter);
15462               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15463
15464               if (path)
15465                 gtk_tree_path_free (path);
15466
15467               return TRUE;
15468             }
15469         }
15470
15471       if (node->children)
15472         {
15473           gboolean has_child;
15474           GtkTreeIter tmp;
15475
15476           tree = node->children;
15477           node = _gtk_rbtree_first (tree);
15478
15479           tmp = *iter;
15480           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
15481           gtk_tree_path_down (path);
15482
15483           /* sanity check */
15484           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
15485         }
15486       else
15487         {
15488           gboolean done = FALSE;
15489
15490           do
15491             {
15492               node = _gtk_rbtree_next (tree, node);
15493
15494               if (node)
15495                 {
15496                   gboolean has_next;
15497
15498                   has_next = gtk_tree_model_iter_next (model, iter);
15499
15500                   done = TRUE;
15501                   gtk_tree_path_next (path);
15502
15503                   /* sanity check */
15504                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
15505                 }
15506               else
15507                 {
15508                   gboolean has_parent;
15509                   GtkTreeIter tmp_iter = *iter;
15510
15511                   node = tree->parent_node;
15512                   tree = tree->parent_tree;
15513
15514                   if (!tree)
15515                     {
15516                       if (path)
15517                         gtk_tree_path_free (path);
15518
15519                       /* we've run out of tree, done with this func */
15520                       return FALSE;
15521                     }
15522
15523                   has_parent = gtk_tree_model_iter_parent (model,
15524                                                            iter,
15525                                                            &tmp_iter);
15526                   gtk_tree_path_up (path);
15527
15528                   /* sanity check */
15529                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
15530                 }
15531             }
15532           while (!done);
15533         }
15534     }
15535   while (1);
15536
15537   return FALSE;
15538 }
15539
15540 static void
15541 gtk_tree_view_search_init (GtkWidget   *entry,
15542                            GtkTreeView *tree_view)
15543 {
15544   gint ret;
15545   gint count = 0;
15546   const gchar *text;
15547   GtkTreeIter iter;
15548   GtkTreeModel *model;
15549   GtkTreeSelection *selection;
15550
15551   g_return_if_fail (GTK_IS_ENTRY (entry));
15552   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15553
15554   text = gtk_entry_get_text (GTK_ENTRY (entry));
15555
15556   model = gtk_tree_view_get_model (tree_view);
15557   selection = gtk_tree_view_get_selection (tree_view);
15558
15559   /* search */
15560   gtk_tree_selection_unselect_all (selection);
15561   if (tree_view->priv->typeselect_flush_timeout
15562       && !tree_view->priv->search_custom_entry_set)
15563     {
15564       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15565       tree_view->priv->typeselect_flush_timeout =
15566         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15567                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15568                        tree_view);
15569     }
15570
15571   if (*text == '\0')
15572     return;
15573
15574   if (!gtk_tree_model_get_iter_first (model, &iter))
15575     return;
15576
15577   ret = gtk_tree_view_search_iter (model, selection,
15578                                    &iter, text,
15579                                    &count, 1);
15580
15581   if (ret)
15582     tree_view->priv->selected_iter = 1;
15583 }
15584
15585 void
15586 _gtk_tree_view_remove_editable (GtkTreeView       *tree_view,
15587                                 GtkTreeViewColumn *column,
15588                                 GtkCellEditable   *cell_editable)
15589 {
15590   if (tree_view->priv->edited_column == NULL)
15591     return;
15592
15593   g_return_if_fail (column == tree_view->priv->edited_column);
15594
15595   tree_view->priv->edited_column = NULL;
15596
15597   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
15598     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
15599
15600   gtk_container_remove (GTK_CONTAINER (tree_view),
15601                         GTK_WIDGET (cell_editable));
15602
15603   /* FIXME should only redraw a single node */
15604   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15605 }
15606
15607 static gboolean
15608 gtk_tree_view_start_editing (GtkTreeView *tree_view,
15609                              GtkTreePath *cursor_path,
15610                              gboolean     edit_only)
15611 {
15612   GtkTreeIter iter;
15613   GdkRectangle cell_area;
15614   GtkTreeViewColumn *focus_column;
15615   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
15616   gint retval = FALSE;
15617   GtkRBTree *cursor_tree;
15618   GtkRBNode *cursor_node;
15619
15620   g_assert (tree_view->priv->focus_column);
15621   focus_column = tree_view->priv->focus_column;
15622
15623   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
15624     return FALSE;
15625
15626   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
15627       cursor_node == NULL)
15628     return FALSE;
15629
15630   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
15631
15632   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
15633
15634   gtk_tree_view_column_cell_set_cell_data (focus_column,
15635                                            tree_view->priv->model,
15636                                            &iter,
15637                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
15638                                            cursor_node->children ? TRUE : FALSE);
15639   gtk_tree_view_get_cell_area (tree_view,
15640                                cursor_path,
15641                                focus_column,
15642                                &cell_area);
15643
15644   if (gtk_cell_area_activate (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (focus_column)),
15645                               _gtk_tree_view_column_get_context (focus_column),
15646                               GTK_WIDGET (tree_view),
15647                               &cell_area,
15648                               flags, edit_only))
15649     retval = TRUE;
15650
15651   return retval;
15652 }
15653
15654 void
15655 _gtk_tree_view_add_editable (GtkTreeView       *tree_view,
15656                              GtkTreeViewColumn *column,
15657                              GtkTreePath       *path,
15658                              GtkCellEditable   *cell_editable,
15659                              GdkRectangle      *cell_area)
15660 {
15661   gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
15662   GtkRequisition requisition;
15663
15664   tree_view->priv->edited_column = column;
15665
15666   gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15667   cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
15668
15669   gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
15670                                  &requisition, NULL);
15671
15672   tree_view->priv->draw_keyfocus = TRUE;
15673
15674   if (requisition.height < cell_area->height)
15675     {
15676       gint diff = cell_area->height - requisition.height;
15677       gtk_tree_view_put (tree_view,
15678                          GTK_WIDGET (cell_editable),
15679                          cell_area->x, cell_area->y + diff/2,
15680                          cell_area->width, requisition.height);
15681     }
15682   else
15683     {
15684       gtk_tree_view_put (tree_view,
15685                          GTK_WIDGET (cell_editable),
15686                          cell_area->x, cell_area->y,
15687                          cell_area->width, cell_area->height);
15688     }
15689 }
15690
15691 static void
15692 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
15693                             gboolean     cancel_editing)
15694 {
15695   GtkTreeViewColumn *column;
15696
15697   if (tree_view->priv->edited_column == NULL)
15698     return;
15699
15700   /*
15701    * This is very evil. We need to do this, because
15702    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
15703    * later on. If gtk_tree_view_row_changed notices
15704    * tree_view->priv->edited_column != NULL, it'll call
15705    * gtk_tree_view_stop_editing again. Bad things will happen then.
15706    *
15707    * Please read that again if you intend to modify anything here.
15708    */
15709
15710   column = tree_view->priv->edited_column;
15711   gtk_cell_area_stop_editing (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)), cancel_editing);
15712   tree_view->priv->edited_column = NULL;
15713 }
15714
15715
15716 /**
15717  * gtk_tree_view_set_hover_selection:
15718  * @tree_view: a #GtkTreeView
15719  * @hover: %TRUE to enable hover selection mode
15720  *
15721  * Enables or disables the hover selection mode of @tree_view.
15722  * Hover selection makes the selected row follow the pointer.
15723  * Currently, this works only for the selection modes
15724  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
15725  *
15726  * Since: 2.6
15727  **/
15728 void
15729 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
15730                                    gboolean     hover)
15731 {
15732   hover = hover != FALSE;
15733
15734   if (hover != tree_view->priv->hover_selection)
15735     {
15736       tree_view->priv->hover_selection = hover;
15737
15738       g_object_notify (G_OBJECT (tree_view), "hover-selection");
15739     }
15740 }
15741
15742 /**
15743  * gtk_tree_view_get_hover_selection:
15744  * @tree_view: a #GtkTreeView
15745  *
15746  * Returns whether hover selection mode is turned on for @tree_view.
15747  *
15748  * Return value: %TRUE if @tree_view is in hover selection mode
15749  *
15750  * Since: 2.6
15751  **/
15752 gboolean
15753 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
15754 {
15755   return tree_view->priv->hover_selection;
15756 }
15757
15758 /**
15759  * gtk_tree_view_set_hover_expand:
15760  * @tree_view: a #GtkTreeView
15761  * @expand: %TRUE to enable hover selection mode
15762  *
15763  * Enables or disables the hover expansion mode of @tree_view.
15764  * Hover expansion makes rows expand or collapse if the pointer
15765  * moves over them.
15766  *
15767  * Since: 2.6
15768  **/
15769 void
15770 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
15771                                 gboolean     expand)
15772 {
15773   expand = expand != FALSE;
15774
15775   if (expand != tree_view->priv->hover_expand)
15776     {
15777       tree_view->priv->hover_expand = expand;
15778
15779       g_object_notify (G_OBJECT (tree_view), "hover-expand");
15780     }
15781 }
15782
15783 /**
15784  * gtk_tree_view_get_hover_expand:
15785  * @tree_view: a #GtkTreeView
15786  *
15787  * Returns whether hover expansion mode is turned on for @tree_view.
15788  *
15789  * Return value: %TRUE if @tree_view is in hover expansion mode
15790  *
15791  * Since: 2.6
15792  **/
15793 gboolean
15794 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
15795 {
15796   return tree_view->priv->hover_expand;
15797 }
15798
15799 /**
15800  * gtk_tree_view_set_rubber_banding:
15801  * @tree_view: a #GtkTreeView
15802  * @enable: %TRUE to enable rubber banding
15803  *
15804  * Enables or disables rubber banding in @tree_view.  If the selection mode
15805  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
15806  * multiple rows by dragging the mouse.
15807  *
15808  * Since: 2.10
15809  **/
15810 void
15811 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
15812                                   gboolean     enable)
15813 {
15814   enable = enable != FALSE;
15815
15816   if (enable != tree_view->priv->rubber_banding_enable)
15817     {
15818       tree_view->priv->rubber_banding_enable = enable;
15819
15820       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
15821     }
15822 }
15823
15824 /**
15825  * gtk_tree_view_get_rubber_banding:
15826  * @tree_view: a #GtkTreeView
15827  *
15828  * Returns whether rubber banding is turned on for @tree_view.  If the
15829  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15830  * user to select multiple rows by dragging the mouse.
15831  *
15832  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15833  *
15834  * Since: 2.10
15835  **/
15836 gboolean
15837 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15838 {
15839   return tree_view->priv->rubber_banding_enable;
15840 }
15841
15842 /**
15843  * gtk_tree_view_is_rubber_banding_active:
15844  * @tree_view: a #GtkTreeView
15845  *
15846  * Returns whether a rubber banding operation is currently being done
15847  * in @tree_view.
15848  *
15849  * Return value: %TRUE if a rubber banding operation is currently being
15850  * done in @tree_view.
15851  *
15852  * Since: 2.12
15853  **/
15854 gboolean
15855 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15856 {
15857   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15858
15859   if (tree_view->priv->rubber_banding_enable
15860       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15861     return TRUE;
15862
15863   return FALSE;
15864 }
15865
15866 /**
15867  * gtk_tree_view_get_row_separator_func: (skip)
15868  * @tree_view: a #GtkTreeView
15869  *
15870  * Returns the current row separator function.
15871  *
15872  * Return value: the current row separator function.
15873  *
15874  * Since: 2.6
15875  **/
15876 GtkTreeViewRowSeparatorFunc
15877 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15878 {
15879   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15880
15881   return tree_view->priv->row_separator_func;
15882 }
15883
15884 /**
15885  * gtk_tree_view_set_row_separator_func:
15886  * @tree_view: a #GtkTreeView
15887  * @func: (allow-none): a #GtkTreeViewRowSeparatorFunc
15888  * @data: (allow-none): user data to pass to @func, or %NULL
15889  * @destroy: (allow-none): destroy notifier for @data, or %NULL
15890  *
15891  * Sets the row separator function, which is used to determine
15892  * whether a row should be drawn as a separator. If the row separator
15893  * function is %NULL, no separators are drawn. This is the default value.
15894  *
15895  * Since: 2.6
15896  **/
15897 void
15898 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15899                                       GtkTreeViewRowSeparatorFunc  func,
15900                                       gpointer                     data,
15901                                       GDestroyNotify               destroy)
15902 {
15903   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15904
15905   if (tree_view->priv->row_separator_destroy)
15906     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15907
15908   tree_view->priv->row_separator_func = func;
15909   tree_view->priv->row_separator_data = data;
15910   tree_view->priv->row_separator_destroy = destroy;
15911
15912   /* Have the tree recalculate heights */
15913   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15914   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15915 }
15916
15917
15918 static void
15919 gtk_tree_view_grab_notify (GtkWidget *widget,
15920                            gboolean   was_grabbed)
15921 {
15922   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15923
15924   tree_view->priv->in_grab = !was_grabbed;
15925
15926   if (!was_grabbed)
15927     {
15928       tree_view->priv->pressed_button = -1;
15929
15930       if (tree_view->priv->rubber_band_status)
15931         gtk_tree_view_stop_rubber_band (tree_view);
15932     }
15933 }
15934
15935 static void
15936 gtk_tree_view_state_flags_changed (GtkWidget     *widget,
15937                                    GtkStateFlags  previous_state)
15938 {
15939   if (gtk_widget_get_realized (widget))
15940     gtk_tree_view_ensure_background (GTK_TREE_VIEW (widget));
15941
15942   gtk_widget_queue_draw (widget);
15943 }
15944
15945 /**
15946  * gtk_tree_view_get_grid_lines:
15947  * @tree_view: a #GtkTreeView
15948  *
15949  * Returns which grid lines are enabled in @tree_view.
15950  *
15951  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15952  * are enabled.
15953  *
15954  * Since: 2.10
15955  */
15956 GtkTreeViewGridLines
15957 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15958 {
15959   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15960
15961   return tree_view->priv->grid_lines;
15962 }
15963
15964 /**
15965  * gtk_tree_view_set_grid_lines:
15966  * @tree_view: a #GtkTreeView
15967  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15968  * enable.
15969  *
15970  * Sets which grid lines to draw in @tree_view.
15971  *
15972  * Since: 2.10
15973  */
15974 void
15975 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15976                               GtkTreeViewGridLines   grid_lines)
15977 {
15978   GtkTreeViewPrivate *priv;
15979   GtkWidget *widget;
15980   GtkTreeViewGridLines old_grid_lines;
15981
15982   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15983
15984   priv = tree_view->priv;
15985   widget = GTK_WIDGET (tree_view);
15986
15987   old_grid_lines = priv->grid_lines;
15988   priv->grid_lines = grid_lines;
15989
15990   if (gtk_widget_get_realized (widget))
15991     {
15992       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15993           priv->grid_line_width)
15994         {
15995           priv->grid_line_width = 0;
15996         }
15997
15998       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15999           !priv->grid_line_width)
16000         {
16001           gint8 *dash_list;
16002
16003           gtk_widget_style_get (widget,
16004                                 "grid-line-width", &priv->grid_line_width,
16005                                 "grid-line-pattern", (gchar *)&dash_list,
16006                                 NULL);
16007
16008           if (dash_list)
16009             {
16010               priv->grid_line_dashes[0] = dash_list[0];
16011               if (dash_list[0])
16012                 priv->grid_line_dashes[1] = dash_list[1];
16013
16014               g_free (dash_list);
16015             }
16016           else
16017             {
16018               priv->grid_line_dashes[0] = 1;
16019               priv->grid_line_dashes[1] = 1;
16020             }
16021         }
16022     }
16023
16024   if (old_grid_lines != grid_lines)
16025     {
16026       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16027
16028       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
16029     }
16030 }
16031
16032 /**
16033  * gtk_tree_view_get_enable_tree_lines:
16034  * @tree_view: a #GtkTreeView.
16035  *
16036  * Returns whether or not tree lines are drawn in @tree_view.
16037  *
16038  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
16039  * otherwise.
16040  *
16041  * Since: 2.10
16042  */
16043 gboolean
16044 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
16045 {
16046   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16047
16048   return tree_view->priv->tree_lines_enabled;
16049 }
16050
16051 /**
16052  * gtk_tree_view_set_enable_tree_lines:
16053  * @tree_view: a #GtkTreeView
16054  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
16055  *
16056  * Sets whether to draw lines interconnecting the expanders in @tree_view.
16057  * This does not have any visible effects for lists.
16058  *
16059  * Since: 2.10
16060  */
16061 void
16062 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
16063                                      gboolean     enabled)
16064 {
16065   GtkTreeViewPrivate *priv;
16066   GtkWidget *widget;
16067   gboolean was_enabled;
16068
16069   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16070
16071   enabled = enabled != FALSE;
16072
16073   priv = tree_view->priv;
16074   widget = GTK_WIDGET (tree_view);
16075
16076   was_enabled = priv->tree_lines_enabled;
16077
16078   priv->tree_lines_enabled = enabled;
16079
16080   if (gtk_widget_get_realized (widget))
16081     {
16082       if (!enabled && priv->tree_line_width)
16083         {
16084           priv->tree_line_width = 0;
16085         }
16086
16087       if (enabled && !priv->tree_line_width)
16088         {
16089           gint8 *dash_list;
16090           gtk_widget_style_get (widget,
16091                                 "tree-line-width", &priv->tree_line_width,
16092                                 "tree-line-pattern", (gchar *)&dash_list,
16093                                 NULL);
16094
16095           if (dash_list)
16096             {
16097               priv->tree_line_dashes[0] = dash_list[0];
16098               if (dash_list[0])
16099                 priv->tree_line_dashes[1] = dash_list[1];
16100
16101               g_free (dash_list);
16102             }
16103           else
16104             {
16105               priv->tree_line_dashes[0] = 1;
16106               priv->tree_line_dashes[1] = 1;
16107             }
16108         }
16109     }
16110
16111   if (was_enabled != enabled)
16112     {
16113       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16114
16115       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
16116     }
16117 }
16118
16119
16120 /**
16121  * gtk_tree_view_set_show_expanders:
16122  * @tree_view: a #GtkTreeView
16123  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
16124  *
16125  * Sets whether to draw and enable expanders and indent child rows in
16126  * @tree_view.  When disabled there will be no expanders visible in trees
16127  * and there will be no way to expand and collapse rows by default.  Also
16128  * note that hiding the expanders will disable the default indentation.  You
16129  * can set a custom indentation in this case using
16130  * gtk_tree_view_set_level_indentation().
16131  * This does not have any visible effects for lists.
16132  *
16133  * Since: 2.12
16134  */
16135 void
16136 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
16137                                   gboolean     enabled)
16138 {
16139   gboolean was_enabled;
16140
16141   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16142
16143   enabled = enabled != FALSE;
16144   was_enabled = tree_view->priv->show_expanders;
16145
16146   tree_view->priv->show_expanders = enabled == TRUE;
16147
16148   if (enabled != was_enabled)
16149     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16150 }
16151
16152 /**
16153  * gtk_tree_view_get_show_expanders:
16154  * @tree_view: a #GtkTreeView.
16155  *
16156  * Returns whether or not expanders are drawn in @tree_view.
16157  *
16158  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
16159  * otherwise.
16160  *
16161  * Since: 2.12
16162  */
16163 gboolean
16164 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
16165 {
16166   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16167
16168   return tree_view->priv->show_expanders;
16169 }
16170
16171 /**
16172  * gtk_tree_view_set_level_indentation:
16173  * @tree_view: a #GtkTreeView
16174  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
16175  *
16176  * Sets the amount of extra indentation for child levels to use in @tree_view
16177  * in addition to the default indentation.  The value should be specified in
16178  * pixels, a value of 0 disables this feature and in this case only the default
16179  * indentation will be used.
16180  * This does not have any visible effects for lists.
16181  *
16182  * Since: 2.12
16183  */
16184 void
16185 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
16186                                      gint         indentation)
16187 {
16188   tree_view->priv->level_indentation = indentation;
16189
16190   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16191 }
16192
16193 /**
16194  * gtk_tree_view_get_level_indentation:
16195  * @tree_view: a #GtkTreeView.
16196  *
16197  * Returns the amount, in pixels, of extra indentation for child levels
16198  * in @tree_view.
16199  *
16200  * Return value: the amount of extra indentation for child levels in
16201  * @tree_view.  A return value of 0 means that this feature is disabled.
16202  *
16203  * Since: 2.12
16204  */
16205 gint
16206 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
16207 {
16208   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16209
16210   return tree_view->priv->level_indentation;
16211 }
16212
16213 /**
16214  * gtk_tree_view_set_tooltip_row:
16215  * @tree_view: a #GtkTreeView
16216  * @tooltip: a #GtkTooltip
16217  * @path: a #GtkTreePath
16218  *
16219  * Sets the tip area of @tooltip to be the area covered by the row at @path.
16220  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16221  * See also gtk_tooltip_set_tip_area().
16222  *
16223  * Since: 2.12
16224  */
16225 void
16226 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
16227                                GtkTooltip  *tooltip,
16228                                GtkTreePath *path)
16229 {
16230   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16231   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16232
16233   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
16234 }
16235
16236 /**
16237  * gtk_tree_view_set_tooltip_cell:
16238  * @tree_view: a #GtkTreeView
16239  * @tooltip: a #GtkTooltip
16240  * @path: (allow-none): a #GtkTreePath or %NULL
16241  * @column: (allow-none): a #GtkTreeViewColumn or %NULL
16242  * @cell: (allow-none): a #GtkCellRenderer or %NULL
16243  *
16244  * Sets the tip area of @tooltip to the area @path, @column and @cell have
16245  * in common.  For example if @path is %NULL and @column is set, the tip
16246  * area will be set to the full area covered by @column.  See also
16247  * gtk_tooltip_set_tip_area().
16248  *
16249  * Note that if @path is not specified and @cell is set and part of a column
16250  * containing the expander, the tooltip might not show and hide at the correct
16251  * position.  In such cases @path must be set to the current node under the
16252  * mouse cursor for this function to operate correctly.
16253  *
16254  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16255  *
16256  * Since: 2.12
16257  */
16258 void
16259 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
16260                                 GtkTooltip        *tooltip,
16261                                 GtkTreePath       *path,
16262                                 GtkTreeViewColumn *column,
16263                                 GtkCellRenderer   *cell)
16264 {
16265   GtkAllocation allocation;
16266   GdkRectangle rect;
16267
16268   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16269   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16270   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
16271   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
16272
16273   /* Determine x values. */
16274   if (column && cell)
16275     {
16276       GdkRectangle tmp;
16277       gint start, width;
16278
16279       /* We always pass in path here, whether it is NULL or not.
16280        * For cells in expander columns path must be specified so that
16281        * we can correctly account for the indentation.  This also means
16282        * that the tooltip is constrained vertically by the "Determine y
16283        * values" code below; this is not a real problem since cells actually
16284        * don't stretch vertically in constrast to columns.
16285        */
16286       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
16287       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
16288
16289       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16290                                                          tmp.x + start, 0,
16291                                                          &rect.x, NULL);
16292       rect.width = width;
16293     }
16294   else if (column)
16295     {
16296       GdkRectangle tmp;
16297
16298       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
16299       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16300                                                          tmp.x, 0,
16301                                                          &rect.x, NULL);
16302       rect.width = tmp.width;
16303     }
16304   else
16305     {
16306       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
16307       rect.x = 0;
16308       rect.width = allocation.width;
16309     }
16310
16311   /* Determine y values. */
16312   if (path)
16313     {
16314       GdkRectangle tmp;
16315
16316       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
16317       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16318                                                          0, tmp.y,
16319                                                          NULL, &rect.y);
16320       rect.height = tmp.height;
16321     }
16322   else
16323     {
16324       rect.y = 0;
16325       rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
16326     }
16327
16328   gtk_tooltip_set_tip_area (tooltip, &rect);
16329 }
16330
16331 /**
16332  * gtk_tree_view_get_tooltip_context:
16333  * @tree_view: a #GtkTreeView
16334  * @x: (inout): the x coordinate (relative to widget coordinates)
16335  * @y: (inout): the y coordinate (relative to widget coordinates)
16336  * @keyboard_tip: whether this is a keyboard tooltip or not
16337  * @model: (out) (allow-none) (transfer none): a pointer to receive a
16338  *         #GtkTreeModel or %NULL
16339  * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
16340  * @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
16341  *
16342  * This function is supposed to be used in a #GtkWidget::query-tooltip
16343  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
16344  * which are received in the signal handler, should be passed to this
16345  * function without modification.
16346  *
16347  * The return value indicates whether there is a tree view row at the given
16348  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
16349  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
16350  * @model, @path and @iter which have been provided will be set to point to
16351  * that row and the corresponding model.  @x and @y will always be converted
16352  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
16353  *
16354  * Return value: whether or not the given tooltip context points to a row.
16355  *
16356  * Since: 2.12
16357  */
16358 gboolean
16359 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
16360                                    gint          *x,
16361                                    gint          *y,
16362                                    gboolean       keyboard_tip,
16363                                    GtkTreeModel **model,
16364                                    GtkTreePath  **path,
16365                                    GtkTreeIter   *iter)
16366 {
16367   GtkTreePath *tmppath = NULL;
16368
16369   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16370   g_return_val_if_fail (x != NULL, FALSE);
16371   g_return_val_if_fail (y != NULL, FALSE);
16372
16373   if (keyboard_tip)
16374     {
16375       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
16376
16377       if (!tmppath)
16378         return FALSE;
16379     }
16380   else
16381     {
16382       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
16383                                                          x, y);
16384
16385       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
16386                                           &tmppath, NULL, NULL, NULL))
16387         return FALSE;
16388     }
16389
16390   if (model)
16391     *model = gtk_tree_view_get_model (tree_view);
16392
16393   if (iter)
16394     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
16395                              iter, tmppath);
16396
16397   if (path)
16398     *path = tmppath;
16399   else
16400     gtk_tree_path_free (tmppath);
16401
16402   return TRUE;
16403 }
16404
16405 static gboolean
16406 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
16407                                     gint        x,
16408                                     gint        y,
16409                                     gboolean    keyboard_tip,
16410                                     GtkTooltip *tooltip,
16411                                     gpointer    data)
16412 {
16413   GValue value = G_VALUE_INIT;
16414   GValue transformed = G_VALUE_INIT;
16415   GtkTreeIter iter;
16416   GtkTreePath *path;
16417   GtkTreeModel *model;
16418   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
16419
16420   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
16421                                           &x, &y,
16422                                           keyboard_tip,
16423                                           &model, &path, &iter))
16424     return FALSE;
16425
16426   gtk_tree_model_get_value (model, &iter,
16427                             tree_view->priv->tooltip_column, &value);
16428
16429   g_value_init (&transformed, G_TYPE_STRING);
16430
16431   if (!g_value_transform (&value, &transformed))
16432     {
16433       g_value_unset (&value);
16434       gtk_tree_path_free (path);
16435
16436       return FALSE;
16437     }
16438
16439   g_value_unset (&value);
16440
16441   if (!g_value_get_string (&transformed))
16442     {
16443       g_value_unset (&transformed);
16444       gtk_tree_path_free (path);
16445
16446       return FALSE;
16447     }
16448
16449   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
16450   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
16451
16452   gtk_tree_path_free (path);
16453   g_value_unset (&transformed);
16454
16455   return TRUE;
16456 }
16457
16458 /**
16459  * gtk_tree_view_set_tooltip_column:
16460  * @tree_view: a #GtkTreeView
16461  * @column: an integer, which is a valid column number for @tree_view's model
16462  *
16463  * If you only plan to have simple (text-only) tooltips on full rows, you
16464  * can use this function to have #GtkTreeView handle these automatically
16465  * for you. @column should be set to the column in @tree_view's model
16466  * containing the tooltip texts, or -1 to disable this feature.
16467  *
16468  * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
16469  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
16470  *
16471  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
16472  * so &amp;, &lt;, etc have to be escaped in the text.
16473  *
16474  * Since: 2.12
16475  */
16476 void
16477 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
16478                                   gint         column)
16479 {
16480   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16481
16482   if (column == tree_view->priv->tooltip_column)
16483     return;
16484
16485   if (column == -1)
16486     {
16487       g_signal_handlers_disconnect_by_func (tree_view,
16488                                             gtk_tree_view_set_tooltip_query_cb,
16489                                             NULL);
16490       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
16491     }
16492   else
16493     {
16494       if (tree_view->priv->tooltip_column == -1)
16495         {
16496           g_signal_connect (tree_view, "query-tooltip",
16497                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
16498           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
16499         }
16500     }
16501
16502   tree_view->priv->tooltip_column = column;
16503   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
16504 }
16505
16506 /**
16507  * gtk_tree_view_get_tooltip_column:
16508  * @tree_view: a #GtkTreeView
16509  *
16510  * Returns the column of @tree_view's model which is being used for
16511  * displaying tooltips on @tree_view's rows.
16512  *
16513  * Return value: the index of the tooltip column that is currently being
16514  * used, or -1 if this is disabled.
16515  *
16516  * Since: 2.12
16517  */
16518 gint
16519 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
16520 {
16521   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16522
16523   return tree_view->priv->tooltip_column;
16524 }