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

   1 /* gtktreeview.c
   2  * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20
  21 #include "config.h"
  22
  23 #include <math.h>
  24 #include <string.h>
  25
  26 #include "gtktreeview.h"
  27 #include "gtkrbtree.h"
  28 #include "gtktreednd.h"
  29 #include "gtktreeprivate.h"
  30 #include "gtkcellrenderer.h"
  31 #include "gtkmarshalers.h"
  32 #include "gtkbuildable.h"
  33 #include "gtkbutton.h"
  34 #include "gtklabel.h"
  35 #include "gtkbox.h"
  36 #include "gtkarrow.h"
  37 #include "gtkintl.h"
  38 #include "gtkbindings.h"
  39 #include "gtkcontainer.h"
  40 #include "gtkentry.h"
  41 #include "gtkframe.h"
  42 #include "gtkmain.h"
  43 #include "gtktreemodelsort.h"
  44 #include "gtktooltip.h"
  45 #include "gtkscrollable.h"
  46 #include "gtkcelllayout.h"
  47 #include "gtkprivate.h"
  48 #include "gtkwidgetprivate.h"
  49 #include "gtkentryprivate.h"
  50 #include "gtkstylecontextprivate.h"
  51 #include "gtktypebuiltins.h"
  52 #include "gtkmain.h"
  53 #include "a11y/gtktreeviewaccessible.h"
  54
  55
  56 /**
  57  * SECTION:gtktreeview
  58  * @Short_description: A widget for displaying both trees and lists
  59  * @Title: GtkTreeView
  60  * @See_also: #GtkTreeViewColumn, #GtkTreeSelection, #GtkTreeDnd, #GtkTreeMode,
  61  *   #GtkTreeSortable, #GtkTreeModelSort, #GtkListStore, #GtkTreeStore,
  62  *   #GtkCellRenderer, #GtkCellEditable, #GtkCellRendererPixbuf,
  63  *   #GtkCellRendererText, #GtkCellRendererToggle
  64  *
  65  * Widget that displays any object that implements the #GtkTreeModel interface.
  66  *
  67  * Please refer to the <link linkend="TreeWidget">tree widget conceptual
  68  * overview</link> for an overview of all the objects and data types related
  69  * to the tree widget and how they work together.
  70  *
  71  * Several different coordinate systems are exposed in the GtkTreeView API.
  72  * These are:
  73  *
  74  * <inlinegraphic fileref="tree-view-coordinates.png" format="PNG"></inlinegraphic>
  75  * <variablelist><title>Coordinate systems in GtkTreeView API</title>
  76  * <varlistentry><term>Widget coordinates</term>
  77  * <listitem>
  78  * <para>
  79  * Coordinates relative to the widget (usually <literal>widget->window</literal>).
  80  * </para>
  81  * </listitem>
  82  * </varlistentry>
  83  * <varlistentry><term>Bin window coordinates</term>
  84  * <listitem>
  85  * <para>
  86  * Coordinates relative to the window that GtkTreeView renders to.
  87  * </para>
  88  * </listitem>
  89  * </varlistentry>
  90  * <varlistentry><term>Tree coordinates</term>
  91  * <listitem>
  92  * <para>
  93  * Coordinates relative to the entire scrollable area of GtkTreeView. These
  94  * coordinates start at (0, 0) for row 0 of the tree.
  95  * </para>
  96  * </listitem>
  97  * </varlistentry>
  98  * </variablelist>
  99  *
 100  * Several functions are available for converting between the different
 101  * coordinate systems.  The most common translations are between widget and bin
 102  * window coordinates and between bin window and tree coordinates. For the
 103  * former you can use gtk_tree_view_convert_widget_to_bin_window_coords()
 104  * (and vice versa), for the latter gtk_tree_view_convert_bin_window_to_tree_coords()
 105  * (and vice versa).
 106  *
 107  * <refsect2 id="GtkTreeView-BUILDER-UI">
 108  * <title>GtkTreeView as GtkBuildable</title>
 109  * The GtkTreeView implementation of the GtkBuildable interface accepts
 110  * #GtkTreeViewColumn objects as &lt;child&gt; elements and exposes the
 111  * internal #GtkTreeSelection in UI definitions.
 112  * <example>
 113  * <title>A UI definition fragment with GtkTreeView</title>
 114  * <programlisting><![CDATA[
 115  * <object class="GtkTreeView" id="treeview">
 116  *   <property name="model">liststore1</property>
 117  *   <child>
 118  *     <object class="GtkTreeViewColumn" id="test-column">
 119  *       <property name="title">Test</property>
 120  *       <child>
 121  *         <object class="GtkCellRendererText" id="test-renderer"/>
 122  *         <attributes>
 123  *           <attribute name="text">1</attribute>
 124  *         </attributes>
 125  *       </child>
 126  *     </object>
 127  *   </child>
 128  *   <child internal-child="selection">
 129  *     <object class="GtkTreeSelection" id="selection">
 130  *       <signal name="changed" handler="on_treeview_selection_changed"/>
 131  *     </object>
 132  *   </child>
 133  * </object>
 134  * ]]></programlisting>
 135  * </example>
 136  * </refsect2>
 137  */
 138
 139 enum
 140 {
 141   DRAG_COLUMN_WINDOW_STATE_UNSET = 0,
 142   DRAG_COLUMN_WINDOW_STATE_ORIGINAL = 1,
 143   DRAG_COLUMN_WINDOW_STATE_ARROW = 2,
 144   DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT = 3,
 145   DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT = 4
 146 };
 147
 148 enum
 149 {
 150   RUBBER_BAND_OFF = 0,
 151   RUBBER_BAND_MAYBE_START = 1,
 152   RUBBER_BAND_ACTIVE = 2
 153 };
 154
 155 typedef enum {
 156   CLEAR_AND_SELECT = (1 << 0),
 157   CLAMP_NODE       = (1 << 1),
 158   CURSOR_INVALID   = (1 << 2)
 159 } SetCursorFlags;
 160
 161  /* This lovely little value is used to determine how far away from the title bar
 162   * you can move the mouse and still have a column drag work.
 163   */
 164 #define TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER(tree_view) (10*gtk_tree_view_get_effective_header_height(tree_view))
 165
 166 #ifdef __GNUC__
 167
 168 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 169      if (!(expr))                                                       \
 170        {                                                                \
 171          g_log (G_LOG_DOMAIN,                                           \
 172                 G_LOG_LEVEL_CRITICAL,                                   \
 173                 "%s (%s): assertion `%s' failed.\n"                     \
 174                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 175                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 176                 "without letting the view know.  Any display from now on is likely to\n"  \
 177                 "be incorrect.\n",                                                        \
 178                 G_STRLOC,                                               \
 179                 G_STRFUNC,                                              \
 180                 #expr);                                                 \
 181          return ret;                                                    \
 182        };                               }G_STMT_END
 183
 184 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 185      if (!(expr))                                                       \
 186        {                                                                \
 187          g_log (G_LOG_DOMAIN,                                           \
 188                 G_LOG_LEVEL_CRITICAL,                                   \
 189                 "%s (%s): assertion `%s' failed.\n"                     \
 190                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 191                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 192                 "without letting the view know.  Any display from now on is likely to\n"  \
 193                 "be incorrect.\n",                                                        \
 194                 G_STRLOC,                                               \
 195                 G_STRFUNC,                                              \
 196                 #expr);                                                 \
 197          return;                                                        \
 198        };                               }G_STMT_END
 199
 200 #else
 201
 202 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 203      if (!(expr))                                                       \
 204        {                                                                \
 205          g_log (G_LOG_DOMAIN,                                           \
 206                 G_LOG_LEVEL_CRITICAL,                                   \
 207                 "file %s: line %d: assertion `%s' failed.\n"       \
 208                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 209                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 210                 "without letting the view know.  Any display from now on is likely to\n"  \
 211                 "be incorrect.\n",                                                        \
 212                 __FILE__,                                               \
 213                 __LINE__,                                               \
 214                 #expr);                                                 \
 215          return ret;                                                    \
 216        };                               }G_STMT_END
 217
 218 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 219      if (!(expr))                                                       \
 220        {                                                                \
 221          g_log (G_LOG_DOMAIN,                                           \
 222                 G_LOG_LEVEL_CRITICAL,                                   \
 223                 "file %s: line %d: assertion '%s' failed.\n"            \
 224                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 225                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 226                 "without letting the view know.  Any display from now on is likely to\n"  \
 227                 "be incorrect.\n",                                                        \
 228                 __FILE__,                                               \
 229                 __LINE__,                                               \
 230                 #expr);                                                 \
 231          return;                                                        \
 232        };                               }G_STMT_END
 233 #endif
 234
 235 #define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
 236 #define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2)
 237 #define GTK_TREE_VIEW_TIME_MS_PER_IDLE 30
 238 #define SCROLL_EDGE_SIZE 15
 239 #define EXPANDER_EXTRA_PADDING 4
 240 #define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000
 241 #define AUTO_EXPAND_TIMEOUT 500
 242
 243 /* Translate from bin_window coordinates to rbtree (tree coordinates) and
 244  * vice versa.
 245  */
 246 #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy)
 247 #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy)
 248
 249 typedef struct _GtkTreeViewColumnReorder GtkTreeViewColumnReorder;
 250 struct _GtkTreeViewColumnReorder
 251 {
 252   gint left_align;
 253   gint right_align;
 254   GtkTreeViewColumn *left_column;
 255   GtkTreeViewColumn *right_column;
 256 };
 257
 258 typedef struct _GtkTreeViewChild GtkTreeViewChild;
 259 struct _GtkTreeViewChild
 260 {
 261   GtkWidget *widget;
 262   gint x;
 263   gint y;
 264   gint width;
 265   gint height;
 266 };
 267
 268
 269 typedef struct _TreeViewDragInfo TreeViewDragInfo;
 270 struct _TreeViewDragInfo
 271 {
 272   GdkModifierType start_button_mask;
 273   GtkTargetList *_unused_source_target_list;
 274   GdkDragAction source_actions;
 275
 276   GtkTargetList *_unused_dest_target_list;
 277
 278   guint source_set : 1;
 279   guint dest_set : 1;
 280 };
 281
 282
 283 struct _GtkTreeViewPrivate
 284 {
 285   GtkTreeModel *model;
 286
 287   /* tree information */
 288   GtkRBTree *tree;
 289
 290   /* Container info */
 291   GList *children;
 292   gint width;
 293   gint height;
 294
 295   /* Adjustments */
 296   GtkAdjustment *hadjustment;
 297   GtkAdjustment *vadjustment;
 298   gint           min_display_width;
 299   gint           min_display_height;
 300
 301   /* Sub windows */
 302   GdkWindow *bin_window;
 303   GdkWindow *header_window;
 304
 305   /* Scroll position state keeping */
 306   GtkTreeRowReference *top_row;
 307   gint top_row_dy;
 308   /* dy == y pos of top_row + top_row_dy */
 309   /* we cache it for simplicity of the code */
 310   gint dy;
 311
 312   guint presize_handler_timer;
 313   guint validate_rows_timer;
 314   guint scroll_sync_timer;
 315
 316   /* Indentation and expander layout */
 317   gint expander_size;
 318   GtkTreeViewColumn *expander_column;
 319
 320   gint level_indentation;
 321
 322   /* Key navigation (focus), selection */
 323   gint cursor_offset;
 324
 325   GtkTreeRowReference *anchor;
 326   GtkRBNode *cursor_node;
 327   GtkRBTree *cursor_tree;
 328
 329   GtkTreeViewColumn *focus_column;
 330
 331   /* Current pressed node, previously pressed, prelight */
 332   GtkRBNode *button_pressed_node;
 333   GtkRBTree *button_pressed_tree;
 334
 335   gint pressed_button;
 336   gint press_start_x;
 337   gint press_start_y;
 338
 339   gint event_last_x;
 340   gint event_last_y;
 341
 342   guint last_button_time;
 343   gint last_button_x;
 344   gint last_button_y;
 345
 346   GtkRBNode *prelight_node;
 347   GtkRBTree *prelight_tree;
 348
 349   /* Cell Editing */
 350   GtkTreeViewColumn *edited_column;
 351
 352   /* The node that's currently being collapsed or expanded */
 353   GtkRBNode *expanded_collapsed_node;
 354   GtkRBTree *expanded_collapsed_tree;
 355   guint expand_collapse_timeout;
 356
 357   /* Auto expand/collapse timeout in hover mode */
 358   guint auto_expand_timeout;
 359
 360   /* Selection information */
 361   GtkTreeSelection *selection;
 362
 363   /* Header information */
 364   gint n_columns;
 365   GList *columns;
 366   gint header_height;
 367
 368   GtkTreeViewColumnDropFunc column_drop_func;
 369   gpointer column_drop_func_data;
 370   GDestroyNotify column_drop_func_data_destroy;
 371   GList *column_drag_info;
 372   GtkTreeViewColumnReorder *cur_reorder;
 373
 374   gint prev_width_before_expander;
 375
 376   /* Interactive Header reordering */
 377   GdkWindow *drag_window;
 378   GdkWindow *drag_highlight_window;
 379   GtkTreeViewColumn *drag_column;
 380   gint drag_column_x;
 381
 382   /* Interactive Header Resizing */
 383   gint drag_pos;
 384   gint x_drag;
 385
 386   /* Non-interactive Header Resizing, expand flag support */
 387   gint prev_width;
 388
 389   gint last_extra_space;
 390   gint last_extra_space_per_column;
 391   gint last_number_of_expand_columns;
 392
 393   /* ATK Hack */
 394   GtkTreeDestroyCountFunc destroy_count_func;
 395   gpointer destroy_count_data;
 396   GDestroyNotify destroy_count_destroy;
 397
 398   /* Scroll timeout (e.g. during dnd, rubber banding) */
 399   guint scroll_timeout;
 400
 401   /* Row drag-and-drop */
 402   GtkTreeRowReference *drag_dest_row;
 403   GtkTreeViewDropPosition drag_dest_pos;
 404   guint open_dest_timeout;
 405
 406   /* Rubber banding */
 407   gint rubber_band_status;
 408   gint rubber_band_x;
 409   gint rubber_band_y;
 410   gint rubber_band_extend;
 411   gint rubber_band_modify;
 412
 413   GtkRBNode *rubber_band_start_node;
 414   GtkRBTree *rubber_band_start_tree;
 415
 416   GtkRBNode *rubber_band_end_node;
 417   GtkRBTree *rubber_band_end_tree;
 418
 419   /* fixed height */
 420   gint fixed_height;
 421
 422   /* Scroll-to functionality when unrealized */
 423   GtkTreeRowReference *scroll_to_path;
 424   GtkTreeViewColumn *scroll_to_column;
 425   gfloat scroll_to_row_align;
 426   gfloat scroll_to_col_align;
 427
 428   /* Interactive search */
 429   gint selected_iter;
 430   gint search_column;
 431   GtkTreeViewSearchPositionFunc search_position_func;
 432   GtkTreeViewSearchEqualFunc search_equal_func;
 433   gpointer search_user_data;
 434   GDestroyNotify search_destroy;
 435   gpointer search_position_user_data;
 436   GDestroyNotify search_position_destroy;
 437   GtkWidget *search_window;
 438   GtkWidget *search_entry;
 439   gulong search_entry_changed_id;
 440   guint typeselect_flush_timeout;
 441
 442   /* Grid and tree lines */
 443   GtkTreeViewGridLines grid_lines;
 444   double grid_line_dashes[2];
 445   int grid_line_width;
 446
 447   gboolean tree_lines_enabled;
 448   double tree_line_dashes[2];
 449   int tree_line_width;
 450
 451   /* Row separators */
 452   GtkTreeViewRowSeparatorFunc row_separator_func;
 453   gpointer row_separator_data;
 454   GDestroyNotify row_separator_destroy;
 455
 456   /* Tooltip support */
 457   gint tooltip_column;
 458
 459   /* Here comes the bitfield */
 460   guint scroll_to_use_align : 1;
 461
 462   guint fixed_height_mode : 1;
 463   guint fixed_height_check : 1;
 464
 465   guint reorderable : 1;
 466   guint header_has_focus : 1;
 467   guint drag_column_window_state : 3;
 468   /* hint to display rows in alternating colors */
 469   guint has_rules : 1;
 470   guint mark_rows_col_dirty : 1;
 471
 472   /* for DnD */
 473   guint empty_view_drop : 1;
 474
 475   guint modify_selection_pressed : 1;
 476   guint extend_selection_pressed : 1;
 477
 478   guint init_hadjust_value : 1;
 479
 480   guint in_top_row_to_dy : 1;
 481
 482   /* interactive search */
 483   guint enable_search : 1;
 484   guint disable_popdown : 1;
 485   guint search_custom_entry_set : 1;
 486
 487   guint hover_selection : 1;
 488   guint hover_expand : 1;
 489   guint imcontext_changed : 1;
 490
 491   guint rubber_banding_enable : 1;
 492
 493   guint in_grab : 1;
 494
 495   guint post_validation_flag : 1;
 496
 497   /* Whether our key press handler is to avoid sending an unhandled binding to the search entry */
 498   guint search_entry_avoid_unhandled_binding : 1;
 499
 500   /* GtkScrollablePolicy needs to be checked when
 501    * driving the scrollable adjustment values */
 502   guint hscroll_policy : 1;
 503   guint vscroll_policy : 1;
 504
 505   /* GtkTreeView flags */
 506   guint is_list : 1;
 507   guint show_expanders : 1;
 508   guint in_column_resize : 1;
 509   guint arrow_prelit : 1;
 510   guint headers_visible : 1;
 511   guint draw_keyfocus : 1;
 512   guint model_setup : 1;
 513   guint in_column_drag : 1;
 514 };
 515
 516
 517 /* Signals */
 518 enum
 519 {
 520   ROW_ACTIVATED,
 521   TEST_EXPAND_ROW,
 522   TEST_COLLAPSE_ROW,
 523   ROW_EXPANDED,
 524   ROW_COLLAPSED,
 525   COLUMNS_CHANGED,
 526   CURSOR_CHANGED,
 527   MOVE_CURSOR,
 528   SELECT_ALL,
 529   UNSELECT_ALL,
 530   SELECT_CURSOR_ROW,
 531   TOGGLE_CURSOR_ROW,
 532   EXPAND_COLLAPSE_CURSOR_ROW,
 533   SELECT_CURSOR_PARENT,
 534   START_INTERACTIVE_SEARCH,
 535   LAST_SIGNAL
 536 };
 537
 538 /* Properties */
 539 enum {
 540   PROP_0,
 541   PROP_MODEL,
 542   PROP_HADJUSTMENT,
 543   PROP_VADJUSTMENT,
 544   PROP_HSCROLL_POLICY,
 545   PROP_VSCROLL_POLICY,
 546   PROP_HEADERS_VISIBLE,
 547   PROP_HEADERS_CLICKABLE,
 548   PROP_EXPANDER_COLUMN,
 549   PROP_REORDERABLE,
 550   PROP_RULES_HINT,
 551   PROP_ENABLE_SEARCH,
 552   PROP_SEARCH_COLUMN,
 553   PROP_FIXED_HEIGHT_MODE,
 554   PROP_HOVER_SELECTION,
 555   PROP_HOVER_EXPAND,
 556   PROP_SHOW_EXPANDERS,
 557   PROP_LEVEL_INDENTATION,
 558   PROP_RUBBER_BANDING,
 559   PROP_ENABLE_GRID_LINES,
 560   PROP_ENABLE_TREE_LINES,
 561   PROP_TOOLTIP_COLUMN
 562 };
 563
 564 /* object signals */
 565 static void     gtk_tree_view_finalize             (GObject          *object);
 566 static void     gtk_tree_view_set_property         (GObject         *object,
 567                                                     guint            prop_id,
 568                                                     const GValue    *value,
 569                                                     GParamSpec      *pspec);
 570 static void     gtk_tree_view_get_property         (GObject         *object,
 571                                                     guint            prop_id,
 572                                                     GValue          *value,
 573                                                     GParamSpec      *pspec);
 574
 575 /* gtkwidget signals */
 576 static void     gtk_tree_view_destroy              (GtkWidget        *widget);
 577 static void     gtk_tree_view_realize              (GtkWidget        *widget);
 578 static void     gtk_tree_view_unrealize            (GtkWidget        *widget);
 579 static void     gtk_tree_view_map                  (GtkWidget        *widget);
 580 static void     gtk_tree_view_get_preferred_width  (GtkWidget        *widget,
 581                                                     gint             *minimum,
 582                                                     gint             *natural);
 583 static void     gtk_tree_view_get_preferred_height (GtkWidget        *widget,
 584                                                     gint             *minimum,
 585                                                     gint             *natural);
 586 static void     gtk_tree_view_size_request         (GtkWidget        *widget,
 587                                                     GtkRequisition   *requisition,
 588                                                     gboolean          may_validate);
 589 static void     gtk_tree_view_size_allocate        (GtkWidget        *widget,
 590                                                     GtkAllocation    *allocation);
 591 static gboolean gtk_tree_view_draw                 (GtkWidget        *widget,
 592                                                     cairo_t          *cr);
 593 static gboolean gtk_tree_view_key_press            (GtkWidget        *widget,
 594                                                     GdkEventKey      *event);
 595 static gboolean gtk_tree_view_key_release          (GtkWidget        *widget,
 596                                                     GdkEventKey      *event);
 597 static gboolean gtk_tree_view_motion               (GtkWidget        *widget,
 598                                                     GdkEventMotion   *event);
 599 static gboolean gtk_tree_view_enter_notify         (GtkWidget        *widget,
 600                                                     GdkEventCrossing *event);
 601 static gboolean gtk_tree_view_leave_notify         (GtkWidget        *widget,
 602                                                     GdkEventCrossing *event);
 603 static gboolean gtk_tree_view_button_press         (GtkWidget        *widget,
 604                                                     GdkEventButton   *event);
 605 static gboolean gtk_tree_view_button_release       (GtkWidget        *widget,
 606                                                     GdkEventButton   *event);
 607 static gboolean gtk_tree_view_grab_broken          (GtkWidget          *widget,
 608                                                     GdkEventGrabBroken *event);
 609 #if 0
 610 static gboolean gtk_tree_view_configure            (GtkWidget         *widget,
 611                                                     GdkEventConfigure *event);
 612 #endif
 613
 614 static GtkWidgetPath * gtk_tree_view_get_path_for_child (GtkContainer *container,
 615                                                          GtkWidget    *child);
 616
 617 static void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 618                                                     GtkWidget        *child);
 619 static gint     gtk_tree_view_focus_out            (GtkWidget        *widget,
 620                                                     GdkEventFocus    *event);
 621 static gint     gtk_tree_view_focus                (GtkWidget        *widget,
 622                                                     GtkDirectionType  direction);
 623 static void     gtk_tree_view_grab_focus           (GtkWidget        *widget);
 624 static void     gtk_tree_view_style_updated        (GtkWidget        *widget);
 625 static void     gtk_tree_view_grab_notify          (GtkWidget        *widget,
 626                                                     gboolean          was_grabbed);
 627 static void     gtk_tree_view_state_flags_changed  (GtkWidget        *widget,
 628                                                     GtkStateFlags     previous_state);
 629
 630 /* container signals */
 631 static void     gtk_tree_view_remove               (GtkContainer     *container,
 632                                                     GtkWidget        *widget);
 633 static void     gtk_tree_view_forall               (GtkContainer     *container,
 634                                                     gboolean          include_internals,
 635                                                     GtkCallback       callback,
 636                                                     gpointer          callback_data);
 637
 638 /* Source side drag signals */
 639 static void gtk_tree_view_drag_begin       (GtkWidget        *widget,
 640                                             GdkDragContext   *context);
 641 static void gtk_tree_view_drag_end         (GtkWidget        *widget,
 642                                             GdkDragContext   *context);
 643 static void gtk_tree_view_drag_data_get    (GtkWidget        *widget,
 644                                             GdkDragContext   *context,
 645                                             GtkSelectionData *selection_data,
 646                                             guint             info,
 647                                             guint             time);
 648 static void gtk_tree_view_drag_data_delete (GtkWidget        *widget,
 649                                             GdkDragContext   *context);
 650
 651 /* Target side drag signals */
 652 static void     gtk_tree_view_drag_leave         (GtkWidget        *widget,
 653                                                   GdkDragContext   *context,
 654                                                   guint             time);
 655 static gboolean gtk_tree_view_drag_motion        (GtkWidget        *widget,
 656                                                   GdkDragContext   *context,
 657                                                   gint              x,
 658                                                   gint              y,
 659                                                   guint             time);
 660 static gboolean gtk_tree_view_drag_drop          (GtkWidget        *widget,
 661                                                   GdkDragContext   *context,
 662                                                   gint              x,
 663                                                   gint              y,
 664                                                   guint             time);
 665 static void     gtk_tree_view_drag_data_received (GtkWidget        *widget,
 666                                                   GdkDragContext   *context,
 667                                                   gint              x,
 668                                                   gint              y,
 669                                                   GtkSelectionData *selection_data,
 670                                                   guint             info,
 671                                                   guint             time);
 672
 673 /* tree_model signals */
 674 static gboolean gtk_tree_view_real_move_cursor            (GtkTreeView     *tree_view,
 675                                                            GtkMovementStep  step,
 676                                                            gint             count);
 677 static gboolean gtk_tree_view_real_select_all             (GtkTreeView     *tree_view);
 678 static gboolean gtk_tree_view_real_unselect_all           (GtkTreeView     *tree_view);
 679 static gboolean gtk_tree_view_real_select_cursor_row      (GtkTreeView     *tree_view,
 680                                                            gboolean         start_editing);
 681 static gboolean gtk_tree_view_real_toggle_cursor_row      (GtkTreeView     *tree_view);
 682 static gboolean gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView     *tree_view,
 683                                                                gboolean         logical,
 684                                                                gboolean         expand,
 685                                                                gboolean         open_all);
 686 static gboolean gtk_tree_view_real_select_cursor_parent   (GtkTreeView     *tree_view);
 687 static void gtk_tree_view_row_changed                     (GtkTreeModel    *model,
 688                                                            GtkTreePath     *path,
 689                                                            GtkTreeIter     *iter,
 690                                                            gpointer         data);
 691 static void gtk_tree_view_row_inserted                    (GtkTreeModel    *model,
 692                                                            GtkTreePath     *path,
 693                                                            GtkTreeIter     *iter,
 694                                                            gpointer         data);
 695 static void gtk_tree_view_row_has_child_toggled           (GtkTreeModel    *model,
 696                                                            GtkTreePath     *path,
 697                                                            GtkTreeIter     *iter,
 698                                                            gpointer         data);
 699 static void gtk_tree_view_row_deleted                     (GtkTreeModel    *model,
 700                                                            GtkTreePath     *path,
 701                                                            gpointer         data);
 702 static void gtk_tree_view_rows_reordered                  (GtkTreeModel    *model,
 703                                                            GtkTreePath     *parent,
 704                                                            GtkTreeIter     *iter,
 705                                                            gint            *new_order,
 706                                                            gpointer         data);
 707
 708 /* Incremental reflow */
 709 static gboolean validate_row             (GtkTreeView *tree_view,
 710                                           GtkRBTree   *tree,
 711                                           GtkRBNode   *node,
 712                                           GtkTreeIter *iter,
 713                                           GtkTreePath *path);
 714 static void     validate_visible_area    (GtkTreeView *tree_view);
 715 static gboolean validate_rows_handler    (GtkTreeView *tree_view);
 716 static gboolean do_validate_rows         (GtkTreeView *tree_view,
 717                                           gboolean     size_request);
 718 static gboolean validate_rows            (GtkTreeView *tree_view);
 719 static gboolean presize_handler_callback (gpointer     data);
 720 static void     install_presize_handler  (GtkTreeView *tree_view);
 721 static void     install_scroll_sync_handler (GtkTreeView *tree_view);
 722 static void     gtk_tree_view_set_top_row   (GtkTreeView *tree_view,
 723                                              GtkTreePath *path,
 724                                              gint         offset);
 725 static void     gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view);
 726 static void     gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view);
 727 static void     invalidate_empty_focus      (GtkTreeView *tree_view);
 728
 729 /* Internal functions */
 730 static gboolean gtk_tree_view_is_expander_column             (GtkTreeView        *tree_view,
 731                                                               GtkTreeViewColumn  *column);
 732 static inline gboolean gtk_tree_view_draw_expanders          (GtkTreeView        *tree_view);
 733 static void     gtk_tree_view_add_move_binding               (GtkBindingSet      *binding_set,
 734                                                               guint               keyval,
 735                                                               guint               modmask,
 736                                                               gboolean            add_shifted_binding,
 737                                                               GtkMovementStep     step,
 738                                                               gint                count);
 739 static gint     gtk_tree_view_unref_and_check_selection_tree (GtkTreeView        *tree_view,
 740                                                               GtkRBTree          *tree);
 741 static void     gtk_tree_view_queue_draw_path                (GtkTreeView        *tree_view,
 742                                                               GtkTreePath        *path,
 743                                                               const GdkRectangle *clip_rect);
 744 static void     gtk_tree_view_queue_draw_arrow               (GtkTreeView        *tree_view,
 745                                                               GtkRBTree          *tree,
 746                                                               GtkRBNode          *node);
 747 static void     gtk_tree_view_draw_arrow                     (GtkTreeView        *tree_view,
 748                                                               cairo_t            *cr,
 749                                                               GtkRBTree          *tree,
 750                                                               GtkRBNode          *node);
 751 static void     gtk_tree_view_get_arrow_xrange               (GtkTreeView        *tree_view,
 752                                                               GtkRBTree          *tree,
 753                                                               gint               *x1,
 754                                                               gint               *x2);
 755 static gint     gtk_tree_view_new_column_width               (GtkTreeView        *tree_view,
 756                                                               gint                i,
 757                                                               gint               *x);
 758 static void     gtk_tree_view_adjustment_changed             (GtkAdjustment      *adjustment,
 759                                                               GtkTreeView        *tree_view);
 760 static void     gtk_tree_view_build_tree                     (GtkTreeView        *tree_view,
 761                                                               GtkRBTree          *tree,
 762                                                               GtkTreeIter        *iter,
 763                                                               gint                depth,
 764                                                               gboolean            recurse);
 765 static void     gtk_tree_view_clamp_node_visible             (GtkTreeView        *tree_view,
 766                                                               GtkRBTree          *tree,
 767                                                               GtkRBNode          *node);
 768 static void     gtk_tree_view_clamp_column_visible           (GtkTreeView        *tree_view,
 769                                                               GtkTreeViewColumn  *column,
 770                                                               gboolean            focus_to_cell);
 771 static gboolean gtk_tree_view_maybe_begin_dragging_row       (GtkTreeView        *tree_view,
 772                                                               GdkEventMotion     *event);
 773 static void     gtk_tree_view_focus_to_cursor                (GtkTreeView        *tree_view);
 774 static void     gtk_tree_view_move_cursor_up_down            (GtkTreeView        *tree_view,
 775                                                               gint                count);
 776 static void     gtk_tree_view_move_cursor_page_up_down       (GtkTreeView        *tree_view,
 777                                                               gint                count);
 778 static void     gtk_tree_view_move_cursor_left_right         (GtkTreeView        *tree_view,
 779                                                               gint                count);
 780 static void     gtk_tree_view_move_cursor_start_end          (GtkTreeView        *tree_view,
 781                                                               gint                count);
 782 static gboolean gtk_tree_view_real_collapse_row              (GtkTreeView        *tree_view,
 783                                                               GtkTreePath        *path,
 784                                                               GtkRBTree          *tree,
 785                                                               GtkRBNode          *node,
 786                                                               gboolean            animate);
 787 static gboolean gtk_tree_view_real_expand_row                (GtkTreeView        *tree_view,
 788                                                               GtkTreePath        *path,
 789                                                               GtkRBTree          *tree,
 790                                                               GtkRBNode          *node,
 791                                                               gboolean            open_all,
 792                                                               gboolean            animate);
 793 static void     gtk_tree_view_real_set_cursor                (GtkTreeView        *tree_view,
 794                                                               GtkTreePath        *path,
 795                                                               SetCursorFlags      flags);
 796 static gboolean gtk_tree_view_has_can_focus_cell             (GtkTreeView        *tree_view);
 797 static void     column_sizing_notify                         (GObject            *object,
 798                                                               GParamSpec         *pspec,
 799                                                               gpointer            data);
 800 static void     gtk_tree_view_stop_rubber_band               (GtkTreeView        *tree_view);
 801 static void     update_prelight                              (GtkTreeView        *tree_view,
 802                                                               int                 x,
 803                                                               int                 y);
 804
 805 static inline gint gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view);
 806
 807 static inline gint gtk_tree_view_get_cell_area_y_offset      (GtkTreeView *tree_view,
 808                                                               GtkRBTree   *tree,
 809                                                               GtkRBNode   *node,
 810                                                               gint         vertical_separator);
 811 static inline gint gtk_tree_view_get_cell_area_height        (GtkTreeView *tree_view,
 812                                                               GtkRBNode   *node,
 813                                                               gint         vertical_separator);
 814
 815 static inline gint gtk_tree_view_get_row_y_offset            (GtkTreeView *tree_view,
 816                                                               GtkRBTree   *tree,
 817                                                               GtkRBNode   *node);
 818 static inline gint gtk_tree_view_get_row_height              (GtkTreeView *tree_view,
 819                                                               GtkRBNode   *node);
 820
 821 /* interactive search */
 822 static void     gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view);
 823 static void     gtk_tree_view_search_dialog_hide        (GtkWidget        *search_dialog,
 824                                                          GtkTreeView      *tree_view,
 825                                                          GdkDevice        *device);
 826 static void     gtk_tree_view_search_position_func      (GtkTreeView      *tree_view,
 827                                                          GtkWidget        *search_dialog,
 828                                                          gpointer          user_data);
 829 static void     gtk_tree_view_search_disable_popdown    (GtkEntry         *entry,
 830                                                          GtkMenu          *menu,
 831                                                          gpointer          data);
 832 static void     gtk_tree_view_search_preedit_changed    (GtkIMContext     *im_context,
 833                                                          GtkTreeView      *tree_view);
 834 static void     gtk_tree_view_search_activate           (GtkEntry         *entry,
 835                                                          GtkTreeView      *tree_view);
 836 static gboolean gtk_tree_view_real_search_enable_popdown(gpointer          data);
 837 static void     gtk_tree_view_search_enable_popdown     (GtkWidget        *widget,
 838                                                          gpointer          data);
 839 static gboolean gtk_tree_view_search_delete_event       (GtkWidget        *widget,
 840                                                          GdkEventAny      *event,
 841                                                          GtkTreeView      *tree_view);
 842 static gboolean gtk_tree_view_search_button_press_event (GtkWidget        *widget,
 843                                                          GdkEventButton   *event,
 844                                                          GtkTreeView      *tree_view);
 845 static gboolean gtk_tree_view_search_scroll_event       (GtkWidget        *entry,
 846                                                          GdkEventScroll   *event,
 847                                                          GtkTreeView      *tree_view);
 848 static gboolean gtk_tree_view_search_key_press_event    (GtkWidget        *entry,
 849                                                          GdkEventKey      *event,
 850                                                          GtkTreeView      *tree_view);
 851 static gboolean gtk_tree_view_search_move               (GtkWidget        *window,
 852                                                          GtkTreeView      *tree_view,
 853                                                          gboolean          up);
 854 static gboolean gtk_tree_view_search_equal_func         (GtkTreeModel     *model,
 855                                                          gint              column,
 856                                                          const gchar      *key,
 857                                                          GtkTreeIter      *iter,
 858                                                          gpointer          search_data);
 859 static gboolean gtk_tree_view_search_iter               (GtkTreeModel     *model,
 860                                                          GtkTreeSelection *selection,
 861                                                          GtkTreeIter      *iter,
 862                                                          const gchar      *text,
 863                                                          gint             *count,
 864                                                          gint              n);
 865 static void     gtk_tree_view_search_init               (GtkWidget        *entry,
 866                                                          GtkTreeView      *tree_view);
 867 static void     gtk_tree_view_put                       (GtkTreeView      *tree_view,
 868                                                          GtkWidget        *child_widget,
 869                                                          gint              x,
 870                                                          gint              y,
 871                                                          gint              width,
 872                                                          gint              height);
 873 static gboolean gtk_tree_view_start_editing             (GtkTreeView      *tree_view,
 874                                                          GtkTreePath      *cursor_path,
 875                                                          gboolean          edit_only);
 876 static void gtk_tree_view_stop_editing                  (GtkTreeView *tree_view,
 877                                                          gboolean     cancel_editing);
 878 static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
 879                                                              GdkDevice   *device,
 880                                                              gboolean     keybinding);
 881 static gboolean gtk_tree_view_start_interactive_search      (GtkTreeView *tree_view);
 882 static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
 883                                                          GtkTreeViewColumn *column,
 884                                                          gint               drop_position);
 885
 886 /* GtkBuildable */
 887 static void     gtk_tree_view_buildable_add_child          (GtkBuildable      *tree_view,
 888                                                             GtkBuilder        *builder,
 889                                                             GObject           *child,
 890                                                             const gchar       *type);
 891 static GObject *gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
 892                                                             GtkBuilder        *builder,
 893                                                             const gchar       *childname);
 894 static void     gtk_tree_view_buildable_init               (GtkBuildableIface *iface);
 895
 896 static GtkAdjustment *gtk_tree_view_do_get_hadjustment (GtkTreeView   *tree_view);
 897 static void           gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
 898                                                         GtkAdjustment *adjustment);
 899 static GtkAdjustment *gtk_tree_view_do_get_vadjustment (GtkTreeView   *tree_view);
 900 static void           gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
 901                                                         GtkAdjustment *adjustment);
 902
 903 static gboolean scroll_row_timeout                   (gpointer     data);
 904 static void     add_scroll_timeout                   (GtkTreeView *tree_view);
 905 static void     remove_scroll_timeout                (GtkTreeView *tree_view);
 906
 907 static guint tree_view_signals [LAST_SIGNAL] = { 0 };
 908
 909 \f
 910
 911 /* GType Methods
 912  */
 913
 914 G_DEFINE_TYPE_WITH_CODE (GtkTreeView, gtk_tree_view, GTK_TYPE_CONTAINER,
 915                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 916                                                 gtk_tree_view_buildable_init)
 917                          G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
 918
 919 static void
 920 gtk_tree_view_class_init (GtkTreeViewClass *class)
 921 {
 922   GObjectClass *o_class;
 923   GtkWidgetClass *widget_class;
 924   GtkContainerClass *container_class;
 925   GtkBindingSet *binding_set;
 926
 927   binding_set = gtk_binding_set_by_class (class);
 928
 929   o_class = (GObjectClass *) class;
 930   widget_class = (GtkWidgetClass *) class;
 931   container_class = (GtkContainerClass *) class;
 932
 933   /* GObject signals */
 934   o_class->set_property = gtk_tree_view_set_property;
 935   o_class->get_property = gtk_tree_view_get_property;
 936   o_class->finalize = gtk_tree_view_finalize;
 937
 938   /* GtkWidget signals */
 939   widget_class->destroy = gtk_tree_view_destroy;
 940   widget_class->map = gtk_tree_view_map;
 941   widget_class->realize = gtk_tree_view_realize;
 942   widget_class->unrealize = gtk_tree_view_unrealize;
 943   widget_class->get_preferred_width = gtk_tree_view_get_preferred_width;
 944   widget_class->get_preferred_height = gtk_tree_view_get_preferred_height;
 945   widget_class->size_allocate = gtk_tree_view_size_allocate;
 946   widget_class->button_press_event = gtk_tree_view_button_press;
 947   widget_class->button_release_event = gtk_tree_view_button_release;
 948   widget_class->grab_broken_event = gtk_tree_view_grab_broken;
 949   /*widget_class->configure_event = gtk_tree_view_configure;*/
 950   widget_class->motion_notify_event = gtk_tree_view_motion;
 951   widget_class->draw = gtk_tree_view_draw;
 952   widget_class->key_press_event = gtk_tree_view_key_press;
 953   widget_class->key_release_event = gtk_tree_view_key_release;
 954   widget_class->enter_notify_event = gtk_tree_view_enter_notify;
 955   widget_class->leave_notify_event = gtk_tree_view_leave_notify;
 956   widget_class->focus_out_event = gtk_tree_view_focus_out;
 957   widget_class->drag_begin = gtk_tree_view_drag_begin;
 958   widget_class->drag_end = gtk_tree_view_drag_end;
 959   widget_class->drag_data_get = gtk_tree_view_drag_data_get;
 960   widget_class->drag_data_delete = gtk_tree_view_drag_data_delete;
 961   widget_class->drag_leave = gtk_tree_view_drag_leave;
 962   widget_class->drag_motion = gtk_tree_view_drag_motion;
 963   widget_class->drag_drop = gtk_tree_view_drag_drop;
 964   widget_class->drag_data_received = gtk_tree_view_drag_data_received;
 965   widget_class->focus = gtk_tree_view_focus;
 966   widget_class->grab_focus = gtk_tree_view_grab_focus;
 967   widget_class->style_updated = gtk_tree_view_style_updated;
 968   widget_class->grab_notify = gtk_tree_view_grab_notify;
 969   widget_class->state_flags_changed = gtk_tree_view_state_flags_changed;
 970
 971   /* GtkContainer signals */
 972   container_class->remove = gtk_tree_view_remove;
 973   container_class->forall = gtk_tree_view_forall;
 974   container_class->set_focus_child = gtk_tree_view_set_focus_child;
 975   container_class->get_path_for_child = gtk_tree_view_get_path_for_child;
 976
 977   class->move_cursor = gtk_tree_view_real_move_cursor;
 978   class->select_all = gtk_tree_view_real_select_all;
 979   class->unselect_all = gtk_tree_view_real_unselect_all;
 980   class->select_cursor_row = gtk_tree_view_real_select_cursor_row;
 981   class->toggle_cursor_row = gtk_tree_view_real_toggle_cursor_row;
 982   class->expand_collapse_cursor_row = gtk_tree_view_real_expand_collapse_cursor_row;
 983   class->select_cursor_parent = gtk_tree_view_real_select_cursor_parent;
 984   class->start_interactive_search = gtk_tree_view_start_interactive_search;
 985
 986   /* Properties */
 987
 988   g_object_class_install_property (o_class,
 989                                    PROP_MODEL,
 990                                    g_param_spec_object ("model",
 991                                                         P_("TreeView Model"),
 992                                                         P_("The model for the tree view"),
 993                                                         GTK_TYPE_TREE_MODEL,
 994                                                         GTK_PARAM_READWRITE));
 995
 996   g_object_class_override_property (o_class, PROP_HADJUSTMENT,    "hadjustment");
 997   g_object_class_override_property (o_class, PROP_VADJUSTMENT,    "vadjustment");
 998   g_object_class_override_property (o_class, PROP_HSCROLL_POLICY, "hscroll-policy");
 999   g_object_class_override_property (o_class, PROP_VSCROLL_POLICY, "vscroll-policy");
1000
1001   g_object_class_install_property (o_class,
1002                                    PROP_HEADERS_VISIBLE,
1003                                    g_param_spec_boolean ("headers-visible",
1004                                                          P_("Headers Visible"),
1005                                                          P_("Show the column header buttons"),
1006                                                          TRUE,
1007                                                          GTK_PARAM_READWRITE));
1008
1009   g_object_class_install_property (o_class,
1010                                    PROP_HEADERS_CLICKABLE,
1011                                    g_param_spec_boolean ("headers-clickable",
1012                                                          P_("Headers Clickable"),
1013                                                          P_("Column headers respond to click events"),
1014                                                          TRUE,
1015                                                          GTK_PARAM_READWRITE));
1016
1017   g_object_class_install_property (o_class,
1018                                    PROP_EXPANDER_COLUMN,
1019                                    g_param_spec_object ("expander-column",
1020                                                         P_("Expander Column"),
1021                                                         P_("Set the column for the expander column"),
1022                                                         GTK_TYPE_TREE_VIEW_COLUMN,
1023                                                         GTK_PARAM_READWRITE));
1024
1025   g_object_class_install_property (o_class,
1026                                    PROP_REORDERABLE,
1027                                    g_param_spec_boolean ("reorderable",
1028                                                          P_("Reorderable"),
1029                                                          P_("View is reorderable"),
1030                                                          FALSE,
1031                                                          GTK_PARAM_READWRITE));
1032
1033   g_object_class_install_property (o_class,
1034                                    PROP_RULES_HINT,
1035                                    g_param_spec_boolean ("rules-hint",
1036                                                          P_("Rules Hint"),
1037                                                          P_("Set a hint to the theme engine to draw rows in alternating colors"),
1038                                                          FALSE,
1039                                                          GTK_PARAM_READWRITE));
1040
1041     g_object_class_install_property (o_class,
1042                                      PROP_ENABLE_SEARCH,
1043                                      g_param_spec_boolean ("enable-search",
1044                                                            P_("Enable Search"),
1045                                                            P_("View allows user to search through columns interactively"),
1046                                                            TRUE,
1047                                                            GTK_PARAM_READWRITE));
1048
1049     g_object_class_install_property (o_class,
1050                                      PROP_SEARCH_COLUMN,
1051                                      g_param_spec_int ("search-column",
1052                                                        P_("Search Column"),
1053                                                        P_("Model column to search through during interactive search"),
1054                                                        -1,
1055                                                        G_MAXINT,
1056                                                        -1,
1057                                                        GTK_PARAM_READWRITE));
1058
1059     /**
1060      * GtkTreeView:fixed-height-mode:
1061      *
1062      * Setting the ::fixed-height-mode property to %TRUE speeds up
1063      * #GtkTreeView by assuming that all rows have the same height.
1064      * Only enable this option if all rows are the same height.
1065      * Please see gtk_tree_view_set_fixed_height_mode() for more
1066      * information on this option.
1067      *
1068      * Since: 2.4
1069      **/
1070     g_object_class_install_property (o_class,
1071                                      PROP_FIXED_HEIGHT_MODE,
1072                                      g_param_spec_boolean ("fixed-height-mode",
1073                                                            P_("Fixed Height Mode"),
1074                                                            P_("Speeds up GtkTreeView by assuming that all rows have the same height"),
1075                                                            FALSE,
1076                                                            GTK_PARAM_READWRITE));
1077
1078     /**
1079      * GtkTreeView:hover-selection:
1080      *
1081      * Enables or disables the hover selection mode of @tree_view.
1082      * Hover selection makes the selected row follow the pointer.
1083      * Currently, this works only for the selection modes
1084      * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
1085      *
1086      * This mode is primarily intended for treeviews in popups, e.g.
1087      * in #GtkComboBox or #GtkEntryCompletion.
1088      *
1089      * Since: 2.6
1090      */
1091     g_object_class_install_property (o_class,
1092                                      PROP_HOVER_SELECTION,
1093                                      g_param_spec_boolean ("hover-selection",
1094                                                            P_("Hover Selection"),
1095                                                            P_("Whether the selection should follow the pointer"),
1096                                                            FALSE,
1097                                                            GTK_PARAM_READWRITE));
1098
1099     /**
1100      * GtkTreeView:hover-expand:
1101      *
1102      * Enables or disables the hover expansion mode of @tree_view.
1103      * Hover expansion makes rows expand or collapse if the pointer moves
1104      * over them.
1105      *
1106      * This mode is primarily intended for treeviews in popups, e.g.
1107      * in #GtkComboBox or #GtkEntryCompletion.
1108      *
1109      * Since: 2.6
1110      */
1111     g_object_class_install_property (o_class,
1112                                      PROP_HOVER_EXPAND,
1113                                      g_param_spec_boolean ("hover-expand",
1114                                                            P_("Hover Expand"),
1115                                                            P_("Whether rows should be expanded/collapsed when the pointer moves over them"),
1116                                                            FALSE,
1117                                                            GTK_PARAM_READWRITE));
1118
1119     /**
1120      * GtkTreeView:show-expanders:
1121      *
1122      * %TRUE if the view has expanders.
1123      *
1124      * Since: 2.12
1125      */
1126     g_object_class_install_property (o_class,
1127                                      PROP_SHOW_EXPANDERS,
1128                                      g_param_spec_boolean ("show-expanders",
1129                                                            P_("Show Expanders"),
1130                                                            P_("View has expanders"),
1131                                                            TRUE,
1132                                                            GTK_PARAM_READWRITE));
1133
1134     /**
1135      * GtkTreeView:level-indentation:
1136      *
1137      * Extra indentation for each level.
1138      *
1139      * Since: 2.12
1140      */
1141     g_object_class_install_property (o_class,
1142                                      PROP_LEVEL_INDENTATION,
1143                                      g_param_spec_int ("level-indentation",
1144                                                        P_("Level Indentation"),
1145                                                        P_("Extra indentation for each level"),
1146                                                        0,
1147                                                        G_MAXINT,
1148                                                        0,
1149                                                        GTK_PARAM_READWRITE));
1150
1151     g_object_class_install_property (o_class,
1152                                      PROP_RUBBER_BANDING,
1153                                      g_param_spec_boolean ("rubber-banding",
1154                                                            P_("Rubber Banding"),
1155                                                            P_("Whether to enable selection of multiple items by dragging the mouse pointer"),
1156                                                            FALSE,
1157                                                            GTK_PARAM_READWRITE));
1158
1159     g_object_class_install_property (o_class,
1160                                      PROP_ENABLE_GRID_LINES,
1161                                      g_param_spec_enum ("enable-grid-lines",
1162                                                         P_("Enable Grid Lines"),
1163                                                         P_("Whether grid lines should be drawn in the tree view"),
1164                                                         GTK_TYPE_TREE_VIEW_GRID_LINES,
1165                                                         GTK_TREE_VIEW_GRID_LINES_NONE,
1166                                                         GTK_PARAM_READWRITE));
1167
1168     g_object_class_install_property (o_class,
1169                                      PROP_ENABLE_TREE_LINES,
1170                                      g_param_spec_boolean ("enable-tree-lines",
1171                                                            P_("Enable Tree Lines"),
1172                                                            P_("Whether tree lines should be drawn in the tree view"),
1173                                                            FALSE,
1174                                                            GTK_PARAM_READWRITE));
1175
1176     g_object_class_install_property (o_class,
1177                                      PROP_TOOLTIP_COLUMN,
1178                                      g_param_spec_int ("tooltip-column",
1179                                                        P_("Tooltip Column"),
1180                                                        P_("The column in the model containing the tooltip texts for the rows"),
1181                                                        -1,
1182                                                        G_MAXINT,
1183                                                        -1,
1184                                                        GTK_PARAM_READWRITE));
1185
1186   /* Style properties */
1187 #define _TREE_VIEW_EXPANDER_SIZE 14
1188 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
1189 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
1190
1191   gtk_widget_class_install_style_property (widget_class,
1192                                            g_param_spec_int ("expander-size",
1193                                                              P_("Expander Size"),
1194                                                              P_("Size of the expander arrow"),
1195                                                              0,
1196                                                              G_MAXINT,
1197                                                              _TREE_VIEW_EXPANDER_SIZE,
1198                                                              GTK_PARAM_READABLE));
1199
1200   gtk_widget_class_install_style_property (widget_class,
1201                                            g_param_spec_int ("vertical-separator",
1202                                                              P_("Vertical Separator Width"),
1203                                                              P_("Vertical space between cells.  Must be an even number"),
1204                                                              0,
1205                                                              G_MAXINT,
1206                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
1207                                                              GTK_PARAM_READABLE));
1208
1209   gtk_widget_class_install_style_property (widget_class,
1210                                            g_param_spec_int ("horizontal-separator",
1211                                                              P_("Horizontal Separator Width"),
1212                                                              P_("Horizontal space between cells.  Must be an even number"),
1213                                                              0,
1214                                                              G_MAXINT,
1215                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
1216                                                              GTK_PARAM_READABLE));
1217
1218   gtk_widget_class_install_style_property (widget_class,
1219                                            g_param_spec_boolean ("allow-rules",
1220                                                                  P_("Allow Rules"),
1221                                                                  P_("Allow drawing of alternating color rows"),
1222                                                                  TRUE,
1223                                                                  GTK_PARAM_READABLE));
1224
1225   gtk_widget_class_install_style_property (widget_class,
1226                                            g_param_spec_boolean ("indent-expanders",
1227                                                                  P_("Indent Expanders"),
1228                                                                  P_("Make the expanders indented"),
1229                                                                  TRUE,
1230                                                                  GTK_PARAM_READABLE));
1231
1232   gtk_widget_class_install_style_property (widget_class,
1233                                            g_param_spec_boxed ("even-row-color",
1234                                                                P_("Even Row Color"),
1235                                                                P_("Color to use for even rows"),
1236                                                                GDK_TYPE_COLOR,
1237                                                                GTK_PARAM_READABLE));
1238
1239   gtk_widget_class_install_style_property (widget_class,
1240                                            g_param_spec_boxed ("odd-row-color",
1241                                                                P_("Odd Row Color"),
1242                                                                P_("Color to use for odd rows"),
1243                                                                GDK_TYPE_COLOR,
1244                                                                GTK_PARAM_READABLE));
1245
1246   gtk_widget_class_install_style_property (widget_class,
1247                                            g_param_spec_int ("grid-line-width",
1248                                                              P_("Grid line width"),
1249                                                              P_("Width, in pixels, of the tree view grid lines"),
1250                                                              0, G_MAXINT, 1,
1251                                                              GTK_PARAM_READABLE));
1252
1253   gtk_widget_class_install_style_property (widget_class,
1254                                            g_param_spec_int ("tree-line-width",
1255                                                              P_("Tree line width"),
1256                                                              P_("Width, in pixels, of the tree view lines"),
1257                                                              0, G_MAXINT, 1,
1258                                                              GTK_PARAM_READABLE));
1259
1260   gtk_widget_class_install_style_property (widget_class,
1261                                            g_param_spec_string ("grid-line-pattern",
1262                                                                 P_("Grid line pattern"),
1263                                                                 P_("Dash pattern used to draw the tree view grid lines"),
1264                                                                 "\1\1",
1265                                                                 GTK_PARAM_READABLE));
1266
1267   gtk_widget_class_install_style_property (widget_class,
1268                                            g_param_spec_string ("tree-line-pattern",
1269                                                                 P_("Tree line pattern"),
1270                                                                 P_("Dash pattern used to draw the tree view lines"),
1271                                                                 "\1\1",
1272                                                                 GTK_PARAM_READABLE));
1273
1274   /* Signals */
1275   /**
1276    * GtkTreeView::row-activated:
1277    * @tree_view: the object on which the signal is emitted
1278    * @path: the #GtkTreePath for the activated row
1279    * @column: the #GtkTreeViewColumn in which the activation occurred
1280    *
1281    * The "row-activated" signal is emitted when the method
1282    * gtk_tree_view_row_activated() is called or the user double clicks
1283    * a treeview row. It is also emitted when a non-editable row is
1284    * selected and one of the keys: Space, Shift+Space, Return or
1285    * Enter is pressed.
1286    *
1287    * For selection handling refer to the <link linkend="TreeWidget">tree
1288    * widget conceptual overview</link> as well as #GtkTreeSelection.
1289    */
1290   tree_view_signals[ROW_ACTIVATED] =
1291     g_signal_new (I_("row-activated"),
1292                   G_TYPE_FROM_CLASS (o_class),
1293                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1294                   G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
1295                   NULL, NULL,
1296                   _gtk_marshal_VOID__BOXED_OBJECT,
1297                   G_TYPE_NONE, 2,
1298                   GTK_TYPE_TREE_PATH,
1299                   GTK_TYPE_TREE_VIEW_COLUMN);
1300
1301   /**
1302    * GtkTreeView::test-expand-row:
1303    * @tree_view: the object on which the signal is emitted
1304    * @iter: the tree iter of the row to expand
1305    * @path: a tree path that points to the row
1306    *
1307    * The given row is about to be expanded (show its children nodes). Use this
1308    * signal if you need to control the expandability of individual rows.
1309    *
1310    * Returns: %FALSE to allow expansion, %TRUE to reject
1311    */
1312   tree_view_signals[TEST_EXPAND_ROW] =
1313     g_signal_new (I_("test-expand-row"),
1314                   G_TYPE_FROM_CLASS (o_class),
1315                   G_SIGNAL_RUN_LAST,
1316                   G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
1317                   _gtk_boolean_handled_accumulator, NULL,
1318                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1319                   G_TYPE_BOOLEAN, 2,
1320                   GTK_TYPE_TREE_ITER,
1321                   GTK_TYPE_TREE_PATH);
1322
1323   /**
1324    * GtkTreeView::test-collapse-row:
1325    * @tree_view: the object on which the signal is emitted
1326    * @iter: the tree iter of the row to collapse
1327    * @path: a tree path that points to the row
1328    *
1329    * The given row is about to be collapsed (hide its children nodes). Use this
1330    * signal if you need to control the collapsibility of individual rows.
1331    *
1332    * Returns: %FALSE to allow collapsing, %TRUE to reject
1333    */
1334   tree_view_signals[TEST_COLLAPSE_ROW] =
1335     g_signal_new (I_("test-collapse-row"),
1336                   G_TYPE_FROM_CLASS (o_class),
1337                   G_SIGNAL_RUN_LAST,
1338                   G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
1339                   _gtk_boolean_handled_accumulator, NULL,
1340                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1341                   G_TYPE_BOOLEAN, 2,
1342                   GTK_TYPE_TREE_ITER,
1343                   GTK_TYPE_TREE_PATH);
1344
1345   /**
1346    * GtkTreeView::row-expanded:
1347    * @tree_view: the object on which the signal is emitted
1348    * @iter: the tree iter of the expanded row
1349    * @path: a tree path that points to the row
1350    *
1351    * The given row has been expanded (child nodes are shown).
1352    */
1353   tree_view_signals[ROW_EXPANDED] =
1354     g_signal_new (I_("row-expanded"),
1355                   G_TYPE_FROM_CLASS (o_class),
1356                   G_SIGNAL_RUN_LAST,
1357                   G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
1358                   NULL, NULL,
1359                   _gtk_marshal_VOID__BOXED_BOXED,
1360                   G_TYPE_NONE, 2,
1361                   GTK_TYPE_TREE_ITER,
1362                   GTK_TYPE_TREE_PATH);
1363
1364   /**
1365    * GtkTreeView::row-collapsed:
1366    * @tree_view: the object on which the signal is emitted
1367    * @iter: the tree iter of the collapsed row
1368    * @path: a tree path that points to the row
1369    *
1370    * The given row has been collapsed (child nodes are hidden).
1371    */
1372   tree_view_signals[ROW_COLLAPSED] =
1373     g_signal_new (I_("row-collapsed"),
1374                   G_TYPE_FROM_CLASS (o_class),
1375                   G_SIGNAL_RUN_LAST,
1376                   G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
1377                   NULL, NULL,
1378                   _gtk_marshal_VOID__BOXED_BOXED,
1379                   G_TYPE_NONE, 2,
1380                   GTK_TYPE_TREE_ITER,
1381                   GTK_TYPE_TREE_PATH);
1382
1383   /**
1384    * GtkTreeView::columns-changed:
1385    * @tree_view: the object on which the signal is emitted
1386    *
1387    * The number of columns of the treeview has changed.
1388    */
1389   tree_view_signals[COLUMNS_CHANGED] =
1390     g_signal_new (I_("columns-changed"),
1391                   G_TYPE_FROM_CLASS (o_class),
1392                   G_SIGNAL_RUN_LAST,
1393                   G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
1394                   NULL, NULL,
1395                   _gtk_marshal_VOID__VOID,
1396                   G_TYPE_NONE, 0);
1397
1398   /**
1399    * GtkTreeView::cursor-changed:
1400    * @tree_view: the object on which the signal is emitted
1401    *
1402    * The position of the cursor (focused cell) has changed.
1403    */
1404   tree_view_signals[CURSOR_CHANGED] =
1405     g_signal_new (I_("cursor-changed"),
1406                   G_TYPE_FROM_CLASS (o_class),
1407                   G_SIGNAL_RUN_LAST,
1408                   G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
1409                   NULL, NULL,
1410                   _gtk_marshal_VOID__VOID,
1411                   G_TYPE_NONE, 0);
1412
1413   tree_view_signals[MOVE_CURSOR] =
1414     g_signal_new (I_("move-cursor"),
1415                   G_TYPE_FROM_CLASS (o_class),
1416                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1417                   G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
1418                   NULL, NULL,
1419                   _gtk_marshal_BOOLEAN__ENUM_INT,
1420                   G_TYPE_BOOLEAN, 2,
1421                   GTK_TYPE_MOVEMENT_STEP,
1422                   G_TYPE_INT);
1423
1424   tree_view_signals[SELECT_ALL] =
1425     g_signal_new (I_("select-all"),
1426                   G_TYPE_FROM_CLASS (o_class),
1427                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1428                   G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
1429                   NULL, NULL,
1430                   _gtk_marshal_BOOLEAN__VOID,
1431                   G_TYPE_BOOLEAN, 0);
1432
1433   tree_view_signals[UNSELECT_ALL] =
1434     g_signal_new (I_("unselect-all"),
1435                   G_TYPE_FROM_CLASS (o_class),
1436                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1437                   G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
1438                   NULL, NULL,
1439                   _gtk_marshal_BOOLEAN__VOID,
1440                   G_TYPE_BOOLEAN, 0);
1441
1442   tree_view_signals[SELECT_CURSOR_ROW] =
1443     g_signal_new (I_("select-cursor-row"),
1444                   G_TYPE_FROM_CLASS (o_class),
1445                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1446                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
1447                   NULL, NULL,
1448                   _gtk_marshal_BOOLEAN__BOOLEAN,
1449                   G_TYPE_BOOLEAN, 1,
1450                   G_TYPE_BOOLEAN);
1451
1452   tree_view_signals[TOGGLE_CURSOR_ROW] =
1453     g_signal_new (I_("toggle-cursor-row"),
1454                   G_TYPE_FROM_CLASS (o_class),
1455                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1456                   G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
1457                   NULL, NULL,
1458                   _gtk_marshal_BOOLEAN__VOID,
1459                   G_TYPE_BOOLEAN, 0);
1460
1461   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
1462     g_signal_new (I_("expand-collapse-cursor-row"),
1463                   G_TYPE_FROM_CLASS (o_class),
1464                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1465                   G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
1466                   NULL, NULL,
1467                   _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
1468                   G_TYPE_BOOLEAN, 3,
1469                   G_TYPE_BOOLEAN,
1470                   G_TYPE_BOOLEAN,
1471                   G_TYPE_BOOLEAN);
1472
1473   tree_view_signals[SELECT_CURSOR_PARENT] =
1474     g_signal_new (I_("select-cursor-parent"),
1475                   G_TYPE_FROM_CLASS (o_class),
1476                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1477                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
1478                   NULL, NULL,
1479                   _gtk_marshal_BOOLEAN__VOID,
1480                   G_TYPE_BOOLEAN, 0);
1481
1482   tree_view_signals[START_INTERACTIVE_SEARCH] =
1483     g_signal_new (I_("start-interactive-search"),
1484                   G_TYPE_FROM_CLASS (o_class),
1485                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1486                   G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
1487                   NULL, NULL,
1488                   _gtk_marshal_BOOLEAN__VOID,
1489                   G_TYPE_BOOLEAN, 0);
1490
1491   /* Key bindings */
1492   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Up, 0, TRUE,
1493                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1494   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Up, 0, TRUE,
1495                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1496
1497   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Down, 0, TRUE,
1498                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1499   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Down, 0, TRUE,
1500                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1501
1502   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_p, GDK_CONTROL_MASK, FALSE,
1503                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1504
1505   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_n, GDK_CONTROL_MASK, FALSE,
1506                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1507
1508   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Home, 0, TRUE,
1509                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1510   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Home, 0, TRUE,
1511                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1512
1513   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_End, 0, TRUE,
1514                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1515   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_End, 0, TRUE,
1516                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1517
1518   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Up, 0, TRUE,
1519                                   GTK_MOVEMENT_PAGES, -1);
1520   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0, TRUE,
1521                                   GTK_MOVEMENT_PAGES, -1);
1522
1523   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Down, 0, TRUE,
1524                                   GTK_MOVEMENT_PAGES, 1);
1525   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0, TRUE,
1526                                   GTK_MOVEMENT_PAGES, 1);
1527
1528
1529   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 0, "move-cursor", 2,
1530                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1531                                 G_TYPE_INT, 1);
1532
1533   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 0, "move-cursor", 2,
1534                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1535                                 G_TYPE_INT, -1);
1536
1537   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, 0, "move-cursor", 2,
1538                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1539                                 G_TYPE_INT, 1);
1540
1541   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, 0, "move-cursor", 2,
1542                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1543                                 G_TYPE_INT, -1);
1544
1545   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK,
1546                                 "move-cursor", 2,
1547                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1548                                 G_TYPE_INT, 1);
1549
1550   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
1551                                 "move-cursor", 2,
1552                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1553                                 G_TYPE_INT, -1);
1554
1555   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK,
1556                                 "move-cursor", 2,
1557                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1558                                 G_TYPE_INT, 1);
1559
1560   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
1561                                 "move-cursor", 2,
1562                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1563                                 G_TYPE_INT, -1);
1564
1565   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1566   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1567
1568   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK, "select-all", 0);
1569   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK, "select-all", 0);
1570
1571   gtk_binding_entry_add_signal (binding_set, GDK_KEY_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1572   gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1573
1574   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1575                                 G_TYPE_BOOLEAN, TRUE);
1576   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1577                                 G_TYPE_BOOLEAN, TRUE);
1578
1579   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0, "select-cursor-row", 1,
1580                                 G_TYPE_BOOLEAN, TRUE);
1581   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0, "select-cursor-row", 1,
1582                                 G_TYPE_BOOLEAN, TRUE);
1583   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0, "select-cursor-row", 1,
1584                                 G_TYPE_BOOLEAN, TRUE);
1585   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0, "select-cursor-row", 1,
1586                                 G_TYPE_BOOLEAN, TRUE);
1587   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0, "select-cursor-row", 1,
1588                                 G_TYPE_BOOLEAN, TRUE);
1589
1590   /* expand and collapse rows */
1591   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, 0, "expand-collapse-cursor-row", 3,
1592                                 G_TYPE_BOOLEAN, TRUE,
1593                                 G_TYPE_BOOLEAN, TRUE,
1594                                 G_TYPE_BOOLEAN, FALSE);
1595
1596   gtk_binding_entry_add_signal (binding_set, GDK_KEY_asterisk, 0,
1597                                 "expand-collapse-cursor-row", 3,
1598                                 G_TYPE_BOOLEAN, TRUE,
1599                                 G_TYPE_BOOLEAN, TRUE,
1600                                 G_TYPE_BOOLEAN, TRUE);
1601   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Multiply, 0,
1602                                 "expand-collapse-cursor-row", 3,
1603                                 G_TYPE_BOOLEAN, TRUE,
1604                                 G_TYPE_BOOLEAN, TRUE,
1605                                 G_TYPE_BOOLEAN, TRUE);
1606
1607   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, 0,
1608                                 "expand-collapse-cursor-row", 3,
1609                                 G_TYPE_BOOLEAN, TRUE,
1610                                 G_TYPE_BOOLEAN, FALSE,
1611                                 G_TYPE_BOOLEAN, FALSE);
1612   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Divide, 0,
1613                                 "expand-collapse-cursor-row", 3,
1614                                 G_TYPE_BOOLEAN, TRUE,
1615                                 G_TYPE_BOOLEAN, FALSE,
1616                                 G_TYPE_BOOLEAN, FALSE);
1617
1618   /* Not doable on US keyboards */
1619   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1620                                 G_TYPE_BOOLEAN, TRUE,
1621                                 G_TYPE_BOOLEAN, TRUE,
1622                                 G_TYPE_BOOLEAN, TRUE);
1623   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, 0, "expand-collapse-cursor-row", 3,
1624                                 G_TYPE_BOOLEAN, TRUE,
1625                                 G_TYPE_BOOLEAN, TRUE,
1626                                 G_TYPE_BOOLEAN, FALSE);
1627   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1628                                 G_TYPE_BOOLEAN, TRUE,
1629                                 G_TYPE_BOOLEAN, TRUE,
1630                                 G_TYPE_BOOLEAN, TRUE);
1631   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1632                                 G_TYPE_BOOLEAN, TRUE,
1633                                 G_TYPE_BOOLEAN, TRUE,
1634                                 G_TYPE_BOOLEAN, TRUE);
1635   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_SHIFT_MASK,
1636                                 "expand-collapse-cursor-row", 3,
1637                                 G_TYPE_BOOLEAN, FALSE,
1638                                 G_TYPE_BOOLEAN, TRUE,
1639                                 G_TYPE_BOOLEAN, TRUE);
1640   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_SHIFT_MASK,
1641                                 "expand-collapse-cursor-row", 3,
1642                                 G_TYPE_BOOLEAN, FALSE,
1643                                 G_TYPE_BOOLEAN, TRUE,
1644                                 G_TYPE_BOOLEAN, TRUE);
1645   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right,
1646                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1647                                 "expand-collapse-cursor-row", 3,
1648                                 G_TYPE_BOOLEAN, FALSE,
1649                                 G_TYPE_BOOLEAN, TRUE,
1650                                 G_TYPE_BOOLEAN, TRUE);
1651   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right,
1652                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1653                                 "expand-collapse-cursor-row", 3,
1654                                 G_TYPE_BOOLEAN, FALSE,
1655                                 G_TYPE_BOOLEAN, TRUE,
1656                                 G_TYPE_BOOLEAN, TRUE);
1657
1658   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, 0, "expand-collapse-cursor-row", 3,
1659                                 G_TYPE_BOOLEAN, TRUE,
1660                                 G_TYPE_BOOLEAN, FALSE,
1661                                 G_TYPE_BOOLEAN, FALSE);
1662   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1663                                 G_TYPE_BOOLEAN, TRUE,
1664                                 G_TYPE_BOOLEAN, FALSE,
1665                                 G_TYPE_BOOLEAN, TRUE);
1666   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, 0, "expand-collapse-cursor-row", 3,
1667                                 G_TYPE_BOOLEAN, TRUE,
1668                                 G_TYPE_BOOLEAN, FALSE,
1669                                 G_TYPE_BOOLEAN, FALSE);
1670   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1671                                 G_TYPE_BOOLEAN, TRUE,
1672                                 G_TYPE_BOOLEAN, FALSE,
1673                                 G_TYPE_BOOLEAN, TRUE);
1674   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_SHIFT_MASK,
1675                                 "expand-collapse-cursor-row", 3,
1676                                 G_TYPE_BOOLEAN, FALSE,
1677                                 G_TYPE_BOOLEAN, FALSE,
1678                                 G_TYPE_BOOLEAN, TRUE);
1679   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_SHIFT_MASK,
1680                                 "expand-collapse-cursor-row", 3,
1681                                 G_TYPE_BOOLEAN, FALSE,
1682                                 G_TYPE_BOOLEAN, FALSE,
1683                                 G_TYPE_BOOLEAN, TRUE);
1684   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left,
1685                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1686                                 "expand-collapse-cursor-row", 3,
1687                                 G_TYPE_BOOLEAN, FALSE,
1688                                 G_TYPE_BOOLEAN, FALSE,
1689                                 G_TYPE_BOOLEAN, TRUE);
1690   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left,
1691                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1692                                 "expand-collapse-cursor-row", 3,
1693                                 G_TYPE_BOOLEAN, FALSE,
1694                                 G_TYPE_BOOLEAN, FALSE,
1695                                 G_TYPE_BOOLEAN, TRUE);
1696
1697   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, 0, "select-cursor-parent", 0);
1698   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1699
1700   gtk_binding_entry_add_signal (binding_set, GDK_KEY_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1701
1702   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1703
1704   g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
1705
1706   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TREE_VIEW_ACCESSIBLE);
1707 }
1708
1709 static void
1710 gtk_tree_view_init (GtkTreeView *tree_view)
1711 {
1712   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
1713
1714   gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
1715   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1716
1717   tree_view->priv->show_expanders = TRUE;
1718   tree_view->priv->draw_keyfocus = TRUE;
1719   tree_view->priv->headers_visible = TRUE;
1720
1721   /* We need some padding */
1722   tree_view->priv->dy = 0;
1723   tree_view->priv->cursor_offset = 0;
1724   tree_view->priv->n_columns = 0;
1725   tree_view->priv->header_height = 1;
1726   tree_view->priv->x_drag = 0;
1727   tree_view->priv->drag_pos = -1;
1728   tree_view->priv->header_has_focus = FALSE;
1729   tree_view->priv->pressed_button = -1;
1730   tree_view->priv->press_start_x = -1;
1731   tree_view->priv->press_start_y = -1;
1732   tree_view->priv->reorderable = FALSE;
1733   tree_view->priv->presize_handler_timer = 0;
1734   tree_view->priv->scroll_sync_timer = 0;
1735   tree_view->priv->fixed_height = -1;
1736   tree_view->priv->fixed_height_mode = FALSE;
1737   tree_view->priv->fixed_height_check = 0;
1738   tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
1739   tree_view->priv->enable_search = TRUE;
1740   tree_view->priv->search_column = -1;
1741   tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
1742   tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
1743   tree_view->priv->search_custom_entry_set = FALSE;
1744   tree_view->priv->typeselect_flush_timeout = 0;
1745   tree_view->priv->init_hadjust_value = TRUE;
1746   tree_view->priv->width = 0;
1747
1748   tree_view->priv->hover_selection = FALSE;
1749   tree_view->priv->hover_expand = FALSE;
1750
1751   tree_view->priv->level_indentation = 0;
1752
1753   tree_view->priv->rubber_banding_enable = FALSE;
1754
1755   tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
1756   tree_view->priv->tree_lines_enabled = FALSE;
1757
1758   tree_view->priv->tooltip_column = -1;
1759
1760   tree_view->priv->post_validation_flag = FALSE;
1761
1762   tree_view->priv->last_button_x = -1;
1763   tree_view->priv->last_button_y = -1;
1764
1765   tree_view->priv->event_last_x = -10000;
1766   tree_view->priv->event_last_y = -10000;
1767
1768   gtk_tree_view_do_set_vadjustment (tree_view, NULL);
1769   gtk_tree_view_do_set_hadjustment (tree_view, NULL);
1770 }
1771
1772 \f
1773
1774 /* GObject Methods
1775  */
1776
1777 static void
1778 gtk_tree_view_set_property (GObject         *object,
1779                             guint            prop_id,
1780                             const GValue    *value,
1781                             GParamSpec      *pspec)
1782 {
1783   GtkTreeView *tree_view;
1784
1785   tree_view = GTK_TREE_VIEW (object);
1786
1787   switch (prop_id)
1788     {
1789     case PROP_MODEL:
1790       gtk_tree_view_set_model (tree_view, g_value_get_object (value));
1791       break;
1792     case PROP_HADJUSTMENT:
1793       gtk_tree_view_do_set_hadjustment (tree_view, g_value_get_object (value));
1794       break;
1795     case PROP_VADJUSTMENT:
1796       gtk_tree_view_do_set_vadjustment (tree_view, g_value_get_object (value));
1797       break;
1798     case PROP_HSCROLL_POLICY:
1799       tree_view->priv->hscroll_policy = g_value_get_enum (value);
1800       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1801       break;
1802     case PROP_VSCROLL_POLICY:
1803       tree_view->priv->vscroll_policy = g_value_get_enum (value);
1804       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1805       break;
1806     case PROP_HEADERS_VISIBLE:
1807       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1808       break;
1809     case PROP_HEADERS_CLICKABLE:
1810       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1811       break;
1812     case PROP_EXPANDER_COLUMN:
1813       gtk_tree_view_set_expander_column (tree_view, g_value_get_object (value));
1814       break;
1815     case PROP_REORDERABLE:
1816       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
1817       break;
1818     case PROP_RULES_HINT:
1819       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1820       break;
1821     case PROP_ENABLE_SEARCH:
1822       gtk_tree_view_set_enable_search (tree_view, g_value_get_boolean (value));
1823       break;
1824     case PROP_SEARCH_COLUMN:
1825       gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
1826       break;
1827     case PROP_FIXED_HEIGHT_MODE:
1828       gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
1829       break;
1830     case PROP_HOVER_SELECTION:
1831       tree_view->priv->hover_selection = g_value_get_boolean (value);
1832       break;
1833     case PROP_HOVER_EXPAND:
1834       tree_view->priv->hover_expand = g_value_get_boolean (value);
1835       break;
1836     case PROP_SHOW_EXPANDERS:
1837       gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
1838       break;
1839     case PROP_LEVEL_INDENTATION:
1840       tree_view->priv->level_indentation = g_value_get_int (value);
1841       break;
1842     case PROP_RUBBER_BANDING:
1843       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1844       break;
1845     case PROP_ENABLE_GRID_LINES:
1846       gtk_tree_view_set_grid_lines (tree_view, g_value_get_enum (value));
1847       break;
1848     case PROP_ENABLE_TREE_LINES:
1849       gtk_tree_view_set_enable_tree_lines (tree_view, g_value_get_boolean (value));
1850       break;
1851     case PROP_TOOLTIP_COLUMN:
1852       gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
1853       break;
1854     default:
1855       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1856       break;
1857     }
1858 }
1859
1860 static void
1861 gtk_tree_view_get_property (GObject    *object,
1862                             guint       prop_id,
1863                             GValue     *value,
1864                             GParamSpec *pspec)
1865 {
1866   GtkTreeView *tree_view;
1867
1868   tree_view = GTK_TREE_VIEW (object);
1869
1870   switch (prop_id)
1871     {
1872     case PROP_MODEL:
1873       g_value_set_object (value, tree_view->priv->model);
1874       break;
1875     case PROP_HADJUSTMENT:
1876       g_value_set_object (value, tree_view->priv->hadjustment);
1877       break;
1878     case PROP_VADJUSTMENT:
1879       g_value_set_object (value, tree_view->priv->vadjustment);
1880       break;
1881     case PROP_HSCROLL_POLICY:
1882       g_value_set_enum (value, tree_view->priv->hscroll_policy);
1883       break;
1884     case PROP_VSCROLL_POLICY:
1885       g_value_set_enum (value, tree_view->priv->vscroll_policy);
1886       break;
1887     case PROP_HEADERS_VISIBLE:
1888       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
1889       break;
1890     case PROP_HEADERS_CLICKABLE:
1891       g_value_set_boolean (value, gtk_tree_view_get_headers_clickable (tree_view));
1892       break;
1893     case PROP_EXPANDER_COLUMN:
1894       g_value_set_object (value, tree_view->priv->expander_column);
1895       break;
1896     case PROP_REORDERABLE:
1897       g_value_set_boolean (value, tree_view->priv->reorderable);
1898       break;
1899     case PROP_RULES_HINT:
1900       g_value_set_boolean (value, tree_view->priv->has_rules);
1901       break;
1902     case PROP_ENABLE_SEARCH:
1903       g_value_set_boolean (value, tree_view->priv->enable_search);
1904       break;
1905     case PROP_SEARCH_COLUMN:
1906       g_value_set_int (value, tree_view->priv->search_column);
1907       break;
1908     case PROP_FIXED_HEIGHT_MODE:
1909       g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
1910       break;
1911     case PROP_HOVER_SELECTION:
1912       g_value_set_boolean (value, tree_view->priv->hover_selection);
1913       break;
1914     case PROP_HOVER_EXPAND:
1915       g_value_set_boolean (value, tree_view->priv->hover_expand);
1916       break;
1917     case PROP_SHOW_EXPANDERS:
1918       g_value_set_boolean (value, tree_view->priv->show_expanders);
1919       break;
1920     case PROP_LEVEL_INDENTATION:
1921       g_value_set_int (value, tree_view->priv->level_indentation);
1922       break;
1923     case PROP_RUBBER_BANDING:
1924       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1925       break;
1926     case PROP_ENABLE_GRID_LINES:
1927       g_value_set_enum (value, tree_view->priv->grid_lines);
1928       break;
1929     case PROP_ENABLE_TREE_LINES:
1930       g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
1931       break;
1932     case PROP_TOOLTIP_COLUMN:
1933       g_value_set_int (value, tree_view->priv->tooltip_column);
1934       break;
1935     default:
1936       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1937       break;
1938     }
1939 }
1940
1941 static void
1942 gtk_tree_view_finalize (GObject *object)
1943 {
1944   G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
1945 }
1946
1947
1948 static GtkBuildableIface *parent_buildable_iface;
1949
1950 static void
1951 gtk_tree_view_buildable_init (GtkBuildableIface *iface)
1952 {
1953   parent_buildable_iface = g_type_interface_peek_parent (iface);
1954   iface->add_child = gtk_tree_view_buildable_add_child;
1955   iface->get_internal_child = gtk_tree_view_buildable_get_internal_child;
1956 }
1957
1958 static void
1959 gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
1960                                    GtkBuilder  *builder,
1961                                    GObject     *child,
1962                                    const gchar *type)
1963 {
1964   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (child));
1965 }
1966
1967 static GObject *
1968 gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
1969                                             GtkBuilder        *builder,
1970                                             const gchar       *childname)
1971 {
1972     if (strcmp (childname, "selection") == 0)
1973       return G_OBJECT (GTK_TREE_VIEW (buildable)->priv->selection);
1974
1975     return parent_buildable_iface->get_internal_child (buildable,
1976                                                        builder,
1977                                                        childname);
1978 }
1979
1980 /* GtkWidget Methods
1981  */
1982
1983 static void
1984 gtk_tree_view_free_rbtree (GtkTreeView *tree_view)
1985 {
1986   _gtk_rbtree_free (tree_view->priv->tree);
1987
1988   tree_view->priv->tree = NULL;
1989   tree_view->priv->button_pressed_node = NULL;
1990   tree_view->priv->button_pressed_tree = NULL;
1991   tree_view->priv->prelight_tree = NULL;
1992   tree_view->priv->prelight_node = NULL;
1993   tree_view->priv->expanded_collapsed_node = NULL;
1994   tree_view->priv->expanded_collapsed_tree = NULL;
1995 }
1996
1997 static void
1998 gtk_tree_view_destroy (GtkWidget *widget)
1999 {
2000   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2001   GList *list;
2002
2003   gtk_tree_view_stop_editing (tree_view, TRUE);
2004
2005   if (tree_view->priv->columns != NULL)
2006     {
2007       list = tree_view->priv->columns;
2008       while (list)
2009         {
2010           GtkTreeViewColumn *column;
2011           column = GTK_TREE_VIEW_COLUMN (list->data);
2012           list = list->next;
2013           gtk_tree_view_remove_column (tree_view, column);
2014         }
2015       tree_view->priv->columns = NULL;
2016     }
2017
2018   if (tree_view->priv->tree != NULL)
2019     {
2020       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
2021
2022       gtk_tree_view_free_rbtree (tree_view);
2023     }
2024
2025   if (tree_view->priv->selection != NULL)
2026     {
2027       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
2028       g_object_unref (tree_view->priv->selection);
2029       tree_view->priv->selection = NULL;
2030     }
2031
2032   if (tree_view->priv->scroll_to_path != NULL)
2033     {
2034       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
2035       tree_view->priv->scroll_to_path = NULL;
2036     }
2037
2038   if (tree_view->priv->drag_dest_row != NULL)
2039     {
2040       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
2041       tree_view->priv->drag_dest_row = NULL;
2042     }
2043
2044   if (tree_view->priv->top_row != NULL)
2045     {
2046       gtk_tree_row_reference_free (tree_view->priv->top_row);
2047       tree_view->priv->top_row = NULL;
2048     }
2049
2050   if (tree_view->priv->column_drop_func_data &&
2051       tree_view->priv->column_drop_func_data_destroy)
2052     {
2053       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
2054       tree_view->priv->column_drop_func_data = NULL;
2055     }
2056
2057   if (tree_view->priv->destroy_count_destroy &&
2058       tree_view->priv->destroy_count_data)
2059     {
2060       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
2061       tree_view->priv->destroy_count_data = NULL;
2062     }
2063
2064   gtk_tree_row_reference_free (tree_view->priv->anchor);
2065   tree_view->priv->anchor = NULL;
2066
2067   /* destroy interactive search dialog */
2068   if (tree_view->priv->search_window)
2069     {
2070       gtk_widget_destroy (tree_view->priv->search_window);
2071       tree_view->priv->search_window = NULL;
2072       tree_view->priv->search_entry = NULL;
2073       if (tree_view->priv->typeselect_flush_timeout)
2074         {
2075           g_source_remove (tree_view->priv->typeselect_flush_timeout);
2076           tree_view->priv->typeselect_flush_timeout = 0;
2077         }
2078     }
2079
2080   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
2081     {
2082       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
2083       tree_view->priv->search_user_data = NULL;
2084     }
2085
2086   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
2087     {
2088       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
2089       tree_view->priv->search_position_user_data = NULL;
2090     }
2091
2092   if (tree_view->priv->row_separator_destroy && tree_view->priv->row_separator_data)
2093     {
2094       tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
2095       tree_view->priv->row_separator_data = NULL;
2096     }
2097
2098   gtk_tree_view_set_model (tree_view, NULL);
2099
2100   if (tree_view->priv->hadjustment)
2101     {
2102       g_object_unref (tree_view->priv->hadjustment);
2103       tree_view->priv->hadjustment = NULL;
2104     }
2105   if (tree_view->priv->vadjustment)
2106     {
2107       g_object_unref (tree_view->priv->vadjustment);
2108       tree_view->priv->vadjustment = NULL;
2109     }
2110
2111   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->destroy (widget);
2112 }
2113
2114 /* GtkWidget::map helper */
2115 static void
2116 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
2117 {
2118   GList *list;
2119
2120   g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
2121
2122   if (tree_view->priv->headers_visible)
2123     {
2124       GtkTreeViewColumn *column;
2125       GtkWidget         *button;
2126       GdkWindow         *window;
2127
2128       for (list = tree_view->priv->columns; list; list = list->next)
2129         {
2130           column = list->data;
2131           button = gtk_tree_view_column_get_button (column);
2132
2133           if (gtk_tree_view_column_get_visible (column) && button)
2134             gtk_widget_show_now (button);
2135
2136           if (gtk_widget_get_visible (button) &&
2137               !gtk_widget_get_mapped (button))
2138             gtk_widget_map (button);
2139         }
2140       for (list = tree_view->priv->columns; list; list = list->next)
2141         {
2142           column = list->data;
2143           if (gtk_tree_view_column_get_visible (column) == FALSE)
2144             continue;
2145
2146           window = _gtk_tree_view_column_get_window (column);
2147           if (gtk_tree_view_column_get_resizable (column))
2148             {
2149               gdk_window_raise (window);
2150               gdk_window_show (window);
2151             }
2152           else
2153             gdk_window_hide (window);
2154         }
2155       gdk_window_show (tree_view->priv->header_window);
2156     }
2157 }
2158
2159 static void
2160 gtk_tree_view_map (GtkWidget *widget)
2161 {
2162   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2163   GList *tmp_list;
2164
2165   gtk_widget_set_mapped (widget, TRUE);
2166
2167   tmp_list = tree_view->priv->children;
2168   while (tmp_list)
2169     {
2170       GtkTreeViewChild *child = tmp_list->data;
2171       tmp_list = tmp_list->next;
2172
2173       if (gtk_widget_get_visible (child->widget))
2174         {
2175           if (!gtk_widget_get_mapped (child->widget))
2176             gtk_widget_map (child->widget);
2177         }
2178     }
2179   gdk_window_show (tree_view->priv->bin_window);
2180
2181   gtk_tree_view_map_buttons (tree_view);
2182
2183   gdk_window_show (gtk_widget_get_window (widget));
2184 }
2185
2186 static void
2187 gtk_tree_view_ensure_background (GtkTreeView *tree_view)
2188 {
2189   GtkStyleContext *context;
2190
2191   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
2192
2193   gtk_style_context_save (context);
2194   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
2195   gtk_style_context_set_background (context, tree_view->priv->bin_window);
2196   gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view)));
2197   gtk_style_context_restore (context);
2198
2199   gtk_style_context_set_background (context, tree_view->priv->header_window);
2200 }
2201
2202 static void
2203 gtk_tree_view_realize (GtkWidget *widget)
2204 {
2205   GtkAllocation allocation;
2206   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2207   GdkWindow *window;
2208   GdkWindowAttr attributes;
2209   GList *tmp_list;
2210   gint attributes_mask;
2211
2212   gtk_widget_set_realized (widget, TRUE);
2213
2214   gtk_widget_get_allocation (widget, &allocation);
2215
2216   /* Make the main, clipping window */
2217   attributes.window_type = GDK_WINDOW_CHILD;
2218   attributes.x = allocation.x;
2219   attributes.y = allocation.y;
2220   attributes.width = allocation.width;
2221   attributes.height = allocation.height;
2222   attributes.wclass = GDK_INPUT_OUTPUT;
2223   attributes.visual = gtk_widget_get_visual (widget);
2224   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
2225
2226   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
2227
2228   window = gdk_window_new (gtk_widget_get_parent_window (widget),
2229                            &attributes, attributes_mask);
2230   gtk_widget_set_window (widget, window);
2231   gdk_window_set_user_data (window, widget);
2232
2233   gtk_widget_get_allocation (widget, &allocation);
2234
2235   /* Make the window for the tree */
2236   attributes.x = 0;
2237   attributes.y = gtk_tree_view_get_effective_header_height (tree_view);
2238   attributes.width = MAX (tree_view->priv->width, allocation.width);
2239   attributes.height = allocation.height;
2240   attributes.event_mask = (GDK_EXPOSURE_MASK |
2241                            GDK_SCROLL_MASK |
2242                            GDK_POINTER_MOTION_MASK |
2243                            GDK_ENTER_NOTIFY_MASK |
2244                            GDK_LEAVE_NOTIFY_MASK |
2245                            GDK_BUTTON_PRESS_MASK |
2246                            GDK_BUTTON_RELEASE_MASK |
2247                            gtk_widget_get_events (widget));
2248
2249   tree_view->priv->bin_window = gdk_window_new (window,
2250                                                 &attributes, attributes_mask);
2251   gdk_window_set_user_data (tree_view->priv->bin_window, widget);
2252
2253   gtk_widget_get_allocation (widget, &allocation);
2254
2255   /* Make the column header window */
2256   attributes.x = 0;
2257   attributes.y = 0;
2258   attributes.width = MAX (tree_view->priv->width, allocation.width);
2259   attributes.height = tree_view->priv->header_height;
2260   attributes.event_mask = (GDK_EXPOSURE_MASK |
2261                            GDK_SCROLL_MASK |
2262                            GDK_ENTER_NOTIFY_MASK |
2263                            GDK_LEAVE_NOTIFY_MASK |
2264                            GDK_BUTTON_PRESS_MASK |
2265                            GDK_BUTTON_RELEASE_MASK |
2266                            GDK_KEY_PRESS_MASK |
2267                            GDK_KEY_RELEASE_MASK |
2268                            gtk_widget_get_events (widget));
2269
2270   tree_view->priv->header_window = gdk_window_new (window,
2271                                                    &attributes, attributes_mask);
2272   gdk_window_set_user_data (tree_view->priv->header_window, widget);
2273
2274   gtk_tree_view_ensure_background (tree_view);
2275
2276   tmp_list = tree_view->priv->children;
2277   while (tmp_list)
2278     {
2279       GtkTreeViewChild *child = tmp_list->data;
2280       tmp_list = tmp_list->next;
2281
2282       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
2283     }
2284
2285   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2286     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
2287
2288   /* Need to call those here, since they create GCs */
2289   gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
2290   gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
2291
2292   install_presize_handler (tree_view);
2293 }
2294
2295 static void
2296 gtk_tree_view_unrealize (GtkWidget *widget)
2297 {
2298   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2299   GtkTreeViewPrivate *priv = tree_view->priv;
2300   GtkStyleContext *context;
2301   GList *list;
2302
2303   if (priv->scroll_timeout != 0)
2304     {
2305       g_source_remove (priv->scroll_timeout);
2306       priv->scroll_timeout = 0;
2307     }
2308
2309   if (priv->auto_expand_timeout != 0)
2310     {
2311       g_source_remove (priv->auto_expand_timeout);
2312       priv->auto_expand_timeout = 0;
2313     }
2314
2315   if (priv->open_dest_timeout != 0)
2316     {
2317       g_source_remove (priv->open_dest_timeout);
2318       priv->open_dest_timeout = 0;
2319     }
2320
2321   context = gtk_widget_get_style_context (widget);
2322   gtk_style_context_cancel_animations (context, NULL);
2323
2324   if (priv->presize_handler_timer != 0)
2325     {
2326       g_source_remove (priv->presize_handler_timer);
2327       priv->presize_handler_timer = 0;
2328     }
2329
2330   if (priv->validate_rows_timer != 0)
2331     {
2332       g_source_remove (priv->validate_rows_timer);
2333       priv->validate_rows_timer = 0;
2334     }
2335
2336   if (priv->scroll_sync_timer != 0)
2337     {
2338       g_source_remove (priv->scroll_sync_timer);
2339       priv->scroll_sync_timer = 0;
2340     }
2341
2342   if (priv->typeselect_flush_timeout)
2343     {
2344       g_source_remove (priv->typeselect_flush_timeout);
2345       priv->typeselect_flush_timeout = 0;
2346     }
2347
2348   for (list = priv->columns; list; list = list->next)
2349     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
2350
2351   gdk_window_set_user_data (priv->bin_window, NULL);
2352   gdk_window_destroy (priv->bin_window);
2353   priv->bin_window = NULL;
2354
2355   gdk_window_set_user_data (priv->header_window, NULL);
2356   gdk_window_destroy (priv->header_window);
2357   priv->header_window = NULL;
2358
2359   if (priv->drag_window)
2360     {
2361       gdk_window_set_user_data (priv->drag_window, NULL);
2362       gdk_window_destroy (priv->drag_window);
2363       priv->drag_window = NULL;
2364     }
2365
2366   if (priv->drag_highlight_window)
2367     {
2368       gdk_window_set_user_data (priv->drag_highlight_window, NULL);
2369       gdk_window_destroy (priv->drag_highlight_window);
2370       priv->drag_highlight_window = NULL;
2371     }
2372
2373   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
2374 }
2375
2376 /* GtkWidget::size_request helper */
2377 static void
2378 gtk_tree_view_size_request_columns (GtkTreeView *tree_view)
2379 {
2380   GList *list;
2381
2382   tree_view->priv->header_height = 0;
2383
2384   for (list = tree_view->priv->columns; list; list = list->next)
2385     {
2386       GtkRequisition     requisition;
2387       GtkTreeViewColumn *column = list->data;
2388       GtkWidget         *button = gtk_tree_view_column_get_button (column);
2389
2390       if (button == NULL)
2391         continue;
2392
2393       gtk_widget_get_preferred_size (button, &requisition, NULL);
2394       tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
2395     }
2396 }
2397
2398
2399 /* Called only by ::size_request */
2400 static void
2401 gtk_tree_view_update_size (GtkTreeView *tree_view)
2402 {
2403   GList *list;
2404   GtkTreeViewColumn *column;
2405   gint i;
2406
2407   if (tree_view->priv->model == NULL)
2408     {
2409       tree_view->priv->width = 0;
2410       tree_view->priv->prev_width = 0;
2411       tree_view->priv->height = 0;
2412       return;
2413     }
2414
2415   tree_view->priv->prev_width = tree_view->priv->width;
2416   tree_view->priv->width = 0;
2417
2418   /* keep this in sync with size_allocate below */
2419   for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
2420     {
2421       column = list->data;
2422       if (!gtk_tree_view_column_get_visible (column))
2423         continue;
2424
2425       tree_view->priv->width += _gtk_tree_view_column_request_width (column);
2426     }
2427
2428   if (tree_view->priv->tree == NULL)
2429     tree_view->priv->height = 0;
2430   else
2431     tree_view->priv->height = tree_view->priv->tree->root->offset;
2432 }
2433
2434 static void
2435 gtk_tree_view_size_request (GtkWidget      *widget,
2436                             GtkRequisition *requisition,
2437                             gboolean        may_validate)
2438 {
2439   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2440
2441   if (may_validate)
2442     {
2443       /* we validate some rows initially just to make sure we have some size.
2444        * In practice, with a lot of static lists, this should get a good width.
2445        */
2446       do_validate_rows (tree_view, FALSE);
2447     }
2448
2449   gtk_tree_view_size_request_columns (tree_view);
2450   gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
2451
2452   requisition->width = tree_view->priv->width;
2453   requisition->height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view);
2454 }
2455
2456 static void
2457 gtk_tree_view_get_preferred_width (GtkWidget *widget,
2458                                    gint      *minimum,
2459                                    gint      *natural)
2460 {
2461   GtkRequisition requisition;
2462
2463   gtk_tree_view_size_request (widget, &requisition, TRUE);
2464
2465   *minimum = *natural = requisition.width;
2466 }
2467
2468 static void
2469 gtk_tree_view_get_preferred_height (GtkWidget *widget,
2470                                     gint      *minimum,
2471                                     gint      *natural)
2472 {
2473   GtkRequisition requisition;
2474
2475   gtk_tree_view_size_request (widget, &requisition, TRUE);
2476
2477   *minimum = *natural = requisition.height;
2478 }
2479
2480 static int
2481 gtk_tree_view_calculate_width_before_expander (GtkTreeView *tree_view)
2482 {
2483   int width = 0;
2484   GList *list;
2485   gboolean rtl;
2486
2487   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2488   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2489        list->data != tree_view->priv->expander_column;
2490        list = (rtl ? list->prev : list->next))
2491     {
2492       GtkTreeViewColumn *column = list->data;
2493
2494       width += gtk_tree_view_column_get_width (column);
2495     }
2496
2497   return width;
2498 }
2499
2500 /* GtkWidget::size_allocate helper */
2501 static void
2502 gtk_tree_view_size_allocate_columns (GtkWidget *widget,
2503                                      gboolean  *width_changed)
2504 {
2505   GtkTreeView *tree_view;
2506   GList *list, *first_column, *last_column;
2507   GtkTreeViewColumn *column;
2508   GtkAllocation widget_allocation;
2509   gint width = 0;
2510   gint extra, extra_per_column, extra_for_last;
2511   gint full_requested_width = 0;
2512   gint number_of_expand_columns = 0;
2513   gboolean rtl;
2514   gboolean update_expand;
2515
2516   tree_view = GTK_TREE_VIEW (widget);
2517
2518   for (last_column = g_list_last (tree_view->priv->columns);
2519        last_column &&
2520        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
2521        last_column = last_column->prev)
2522     ;
2523   if (last_column == NULL)
2524     return;
2525
2526   for (first_column = g_list_first (tree_view->priv->columns);
2527        first_column &&
2528        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
2529        first_column = first_column->next)
2530     ;
2531
2532   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2533
2534   /* find out how many extra space and expandable columns we have */
2535   for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
2536     {
2537       column = (GtkTreeViewColumn *)list->data;
2538
2539       if (!gtk_tree_view_column_get_visible (column))
2540         continue;
2541
2542       full_requested_width += _gtk_tree_view_column_request_width (column);
2543
2544       if (gtk_tree_view_column_get_expand (column))
2545         number_of_expand_columns++;
2546     }
2547
2548   /* Only update the expand value if the width of the widget has changed,
2549    * or the number of expand columns has changed, or if there are no expand
2550    * columns, or if we didn't have an size-allocation yet after the
2551    * last validated node.
2552    */
2553   update_expand = (width_changed && *width_changed == TRUE)
2554       || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns
2555       || number_of_expand_columns == 0
2556       || tree_view->priv->post_validation_flag == TRUE;
2557
2558   tree_view->priv->post_validation_flag = FALSE;
2559
2560   gtk_widget_get_allocation (widget, &widget_allocation);
2561   if (!update_expand)
2562     {
2563       extra = tree_view->priv->last_extra_space;
2564       extra_for_last = MAX (widget_allocation.width - full_requested_width - extra, 0);
2565     }
2566   else
2567     {
2568       extra = MAX (widget_allocation.width - full_requested_width, 0);
2569       extra_for_last = 0;
2570
2571       tree_view->priv->last_extra_space = extra;
2572     }
2573
2574   if (number_of_expand_columns > 0)
2575     extra_per_column = extra/number_of_expand_columns;
2576   else
2577     extra_per_column = 0;
2578
2579   if (update_expand)
2580     {
2581       tree_view->priv->last_extra_space_per_column = extra_per_column;
2582       tree_view->priv->last_number_of_expand_columns = number_of_expand_columns;
2583     }
2584
2585   for (list = (rtl ? last_column : first_column);
2586        list != (rtl ? first_column->prev : last_column->next);
2587        list = (rtl ? list->prev : list->next))
2588     {
2589       gint column_width;
2590
2591       column = list->data;
2592
2593       if (!gtk_tree_view_column_get_visible (column))
2594         continue;
2595
2596       /* We need to handle the dragged button specially.
2597        */
2598       if (column == tree_view->priv->drag_column)
2599         {
2600           GtkAllocation drag_allocation;
2601           GtkWidget    *button;
2602
2603           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
2604
2605           drag_allocation.x = 0;
2606           drag_allocation.y = 0;
2607           drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
2608           drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
2609           gtk_widget_size_allocate (button, &drag_allocation);
2610           width += drag_allocation.width;
2611           continue;
2612         }
2613
2614       column_width = _gtk_tree_view_column_request_width (column);
2615
2616       if (gtk_tree_view_column_get_expand (column))
2617         {
2618           if (number_of_expand_columns == 1)
2619             {
2620               /* We add the remander to the last column as
2621                * */
2622               column_width += extra;
2623             }
2624           else
2625             {
2626               column_width += extra_per_column;
2627               extra -= extra_per_column;
2628               number_of_expand_columns --;
2629             }
2630         }
2631       else if (number_of_expand_columns == 0 &&
2632                list == last_column)
2633         {
2634           column_width += extra;
2635         }
2636
2637       /* In addition to expand, the last column can get even more
2638        * extra space so all available space is filled up.
2639        */
2640       if (extra_for_last > 0 && list == last_column)
2641         column_width += extra_for_last;
2642
2643       _gtk_tree_view_column_allocate (column, width, column_width);
2644
2645       width += column_width;
2646     }
2647
2648   /* We change the width here.  The user might have been resizing columns,
2649    * which changes the total width of the tree view.  This is of
2650    * importance for getting the horizontal scroll bar right.
2651    */
2652   if (tree_view->priv->width != width)
2653     {
2654       tree_view->priv->width = width;
2655       if (width_changed)
2656         *width_changed = TRUE;
2657     }
2658 }
2659
2660
2661 static void
2662 gtk_tree_view_size_allocate (GtkWidget     *widget,
2663                              GtkAllocation *allocation)
2664 {
2665   GtkAllocation widget_allocation;
2666   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2667   GList *tmp_list;
2668   gboolean width_changed = FALSE;
2669   gint old_width;
2670
2671   gtk_widget_get_allocation (widget, &widget_allocation);
2672   old_width = widget_allocation.width;
2673   if (allocation->width != widget_allocation.width)
2674     width_changed = TRUE;
2675
2676   gtk_widget_set_allocation (widget, allocation);
2677
2678   tmp_list = tree_view->priv->children;
2679
2680   while (tmp_list)
2681     {
2682       GtkAllocation allocation;
2683
2684       GtkTreeViewChild *child = tmp_list->data;
2685       tmp_list = tmp_list->next;
2686
2687       /* totally ignore our child's requisition */
2688       allocation.x = child->x;
2689       allocation.y = child->y;
2690       allocation.width = child->width;
2691       allocation.height = child->height;
2692       gtk_widget_size_allocate (child->widget, &allocation);
2693     }
2694
2695   /* We size-allocate the columns first because the width of the
2696    * tree view (used in updating the adjustments below) might change.
2697    */
2698   gtk_tree_view_size_allocate_columns (widget, &width_changed);
2699
2700   g_object_freeze_notify (G_OBJECT (tree_view->priv->hadjustment));
2701   gtk_adjustment_set_page_size (tree_view->priv->hadjustment,
2702                                 allocation->width);
2703   gtk_adjustment_set_page_increment (tree_view->priv->hadjustment,
2704                                      allocation->width * 0.9);
2705   gtk_adjustment_set_step_increment (tree_view->priv->hadjustment,
2706                                      allocation->width * 0.1);
2707   gtk_adjustment_set_lower (tree_view->priv->hadjustment, 0);
2708   gtk_adjustment_set_upper (tree_view->priv->hadjustment,
2709                             MAX (gtk_adjustment_get_page_size (tree_view->priv->hadjustment),
2710                                  tree_view->priv->width));
2711   g_object_thaw_notify (G_OBJECT (tree_view->priv->hadjustment));
2712
2713   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2714     {
2715       if (allocation->width < tree_view->priv->width)
2716         {
2717           if (tree_view->priv->init_hadjust_value)
2718             {
2719               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2720                                         MAX (tree_view->priv->width -
2721                                              allocation->width, 0));
2722               tree_view->priv->init_hadjust_value = FALSE;
2723             }
2724           else if (allocation->width != old_width)
2725             {
2726               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2727                                         CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) - allocation->width + old_width,
2728                                                0,
2729                                                tree_view->priv->width - allocation->width));
2730             }
2731           else
2732             gtk_adjustment_set_value (tree_view->priv->hadjustment,
2733                                       CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - gtk_adjustment_get_value (tree_view->priv->hadjustment)),
2734                                              0,
2735                                              tree_view->priv->width - allocation->width));
2736         }
2737       else
2738         {
2739           gtk_adjustment_set_value (tree_view->priv->hadjustment, 0);
2740           tree_view->priv->init_hadjust_value = TRUE;
2741         }
2742     }
2743   else
2744     if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + allocation->width > tree_view->priv->width)
2745       gtk_adjustment_set_value (tree_view->priv->hadjustment,
2746                                 MAX (tree_view->priv->width -
2747                                      allocation->width, 0));
2748
2749   g_object_freeze_notify (G_OBJECT (tree_view->priv->vadjustment));
2750   gtk_adjustment_set_page_size (tree_view->priv->vadjustment,
2751                                 allocation->height -
2752                                 gtk_tree_view_get_effective_header_height (tree_view));
2753   gtk_adjustment_set_step_increment (tree_view->priv->vadjustment,
2754                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.1);
2755   gtk_adjustment_set_page_increment (tree_view->priv->vadjustment,
2756                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.9);
2757   gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
2758   gtk_adjustment_set_upper (tree_view->priv->vadjustment,
2759                             MAX (gtk_adjustment_get_page_size (tree_view->priv->vadjustment),
2760                                  tree_view->priv->height));
2761   g_object_thaw_notify (G_OBJECT (tree_view->priv->vadjustment));
2762
2763   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2764   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
2765     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2766   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
2767     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2768                               tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
2769   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2770     gtk_tree_view_top_row_to_dy (tree_view);
2771   else
2772     gtk_tree_view_dy_to_top_row (tree_view);
2773
2774   if (gtk_widget_get_realized (widget))
2775     {
2776       gdk_window_move_resize (gtk_widget_get_window (widget),
2777                               allocation->x, allocation->y,
2778                               allocation->width, allocation->height);
2779       gdk_window_move_resize (tree_view->priv->header_window,
2780                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2781                               0,
2782                               MAX (tree_view->priv->width, allocation->width),
2783                               tree_view->priv->header_height);
2784       gdk_window_move_resize (tree_view->priv->bin_window,
2785                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2786                               gtk_tree_view_get_effective_header_height (tree_view),
2787                               MAX (tree_view->priv->width, allocation->width),
2788                               allocation->height - gtk_tree_view_get_effective_header_height (tree_view));
2789
2790       if (tree_view->priv->tree == NULL)
2791         invalidate_empty_focus (tree_view);
2792
2793       if (width_changed && tree_view->priv->expander_column)
2794         {
2795           /* Might seem awkward, but is the best heuristic I could come up
2796            * with.  Only if the width of the columns before the expander
2797            * changes, we will update the prelight status.  It is this
2798            * width that makes the expander move vertically.  Always updating
2799            * prelight status causes trouble with hover selections.
2800            */
2801           gint width_before_expander;
2802
2803           width_before_expander = gtk_tree_view_calculate_width_before_expander (tree_view);
2804
2805           if (tree_view->priv->prev_width_before_expander
2806               != width_before_expander)
2807               update_prelight (tree_view,
2808                                tree_view->priv->event_last_x,
2809                                tree_view->priv->event_last_y);
2810
2811           tree_view->priv->prev_width_before_expander = width_before_expander;
2812         }
2813     }
2814 }
2815
2816 /* Grabs the focus and unsets the GTK_TREE_VIEW_DRAW_KEYFOCUS flag */
2817 static void
2818 grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
2819 {
2820   GtkWidget *widget = GTK_WIDGET (tree_view);
2821
2822   if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
2823     gtk_widget_grab_focus (widget);
2824   tree_view->priv->draw_keyfocus = 0;
2825 }
2826
2827 static inline gboolean
2828 row_is_separator (GtkTreeView *tree_view,
2829                   GtkTreeIter *iter,
2830                   GtkTreePath *path)
2831 {
2832   gboolean is_separator = FALSE;
2833
2834   if (tree_view->priv->row_separator_func)
2835     {
2836       GtkTreeIter tmpiter;
2837
2838       if (iter)
2839         tmpiter = *iter;
2840       else
2841         {
2842           if (!gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path))
2843             return FALSE;
2844         }
2845
2846       is_separator = tree_view->priv->row_separator_func (tree_view->priv->model,
2847                                                           &tmpiter,
2848                                                           tree_view->priv->row_separator_data);
2849     }
2850
2851   return is_separator;
2852 }
2853
2854 static gboolean
2855 gtk_tree_view_button_press (GtkWidget      *widget,
2856                             GdkEventButton *event)
2857 {
2858   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2859   GList *list;
2860   GtkTreeViewColumn *column = NULL;
2861   gint i;
2862   GdkRectangle background_area;
2863   GdkRectangle cell_area;
2864   gint vertical_separator;
2865   gint horizontal_separator;
2866   gboolean path_is_selectable;
2867   gboolean rtl;
2868
2869   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2870   gtk_tree_view_stop_editing (tree_view, FALSE);
2871   gtk_widget_style_get (widget,
2872                         "vertical-separator", &vertical_separator,
2873                         "horizontal-separator", &horizontal_separator,
2874                         NULL);
2875
2876   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2877    * we're done handling the button press.
2878    */
2879
2880   if (event->window == tree_view->priv->bin_window)
2881     {
2882       GtkRBNode *node;
2883       GtkRBTree *tree;
2884       GtkTreePath *path;
2885       gint depth;
2886       gint new_y;
2887       gint y_offset;
2888       gint dval;
2889       gint pre_val, aft_val;
2890       GtkTreeViewColumn *column = NULL;
2891       gint column_handled_click = FALSE;
2892       gboolean row_double_click = FALSE;
2893       gboolean rtl;
2894       gboolean node_selected;
2895       GdkModifierType extend_mod_mask;
2896       GdkModifierType modify_mod_mask;
2897
2898       /* Empty tree? */
2899       if (tree_view->priv->tree == NULL)
2900         {
2901           grab_focus_and_unset_draw_keyfocus (tree_view);
2902           return TRUE;
2903         }
2904
2905       /* are we in an arrow? */
2906       if (tree_view->priv->prelight_node &&
2907           tree_view->priv->arrow_prelit &&
2908           gtk_tree_view_draw_expanders (tree_view))
2909         {
2910           if (event->button == GDK_BUTTON_PRIMARY)
2911             {
2912               gtk_grab_add (widget);
2913               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2914               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2915               gtk_tree_view_queue_draw_arrow (GTK_TREE_VIEW (widget),
2916                                               tree_view->priv->prelight_tree,
2917                                               tree_view->priv->prelight_node);
2918             }
2919
2920           grab_focus_and_unset_draw_keyfocus (tree_view);
2921           return TRUE;
2922         }
2923
2924       /* find the node that was clicked */
2925       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
2926       if (new_y < 0)
2927         new_y = 0;
2928       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
2929
2930       if (node == NULL)
2931         {
2932           /* We clicked in dead space */
2933           grab_focus_and_unset_draw_keyfocus (tree_view);
2934           return TRUE;
2935         }
2936
2937       /* Get the path and the node */
2938       path = _gtk_tree_path_new_from_rbtree (tree, node);
2939       path_is_selectable = !row_is_separator (tree_view, NULL, path);
2940
2941       if (!path_is_selectable)
2942         {
2943           gtk_tree_path_free (path);
2944           grab_focus_and_unset_draw_keyfocus (tree_view);
2945           return TRUE;
2946         }
2947
2948       depth = gtk_tree_path_get_depth (path);
2949       background_area.y = y_offset + event->y;
2950       background_area.height = gtk_tree_view_get_row_height (tree_view, node);
2951       background_area.x = 0;
2952
2953
2954       /* Let the column have a chance at selecting it. */
2955       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2956       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2957            list; list = (rtl ? list->prev : list->next))
2958         {
2959           GtkTreeViewColumn *candidate = list->data;
2960
2961           if (!gtk_tree_view_column_get_visible (candidate))
2962             continue;
2963
2964           background_area.width = gtk_tree_view_column_get_width (candidate);
2965           if ((background_area.x > (gint) event->x) ||
2966               (background_area.x + background_area.width <= (gint) event->x))
2967             {
2968               background_area.x += background_area.width;
2969               continue;
2970             }
2971
2972           /* we found the focus column */
2973           column = candidate;
2974           cell_area = background_area;
2975           cell_area.width -= horizontal_separator;
2976           cell_area.height -= vertical_separator;
2977           cell_area.x += horizontal_separator/2;
2978           cell_area.y += vertical_separator/2;
2979           if (gtk_tree_view_is_expander_column (tree_view, column))
2980             {
2981               if (!rtl)
2982                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
2983               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
2984
2985               if (gtk_tree_view_draw_expanders (tree_view))
2986                 {
2987                   if (!rtl)
2988                     cell_area.x += depth * tree_view->priv->expander_size;
2989                   cell_area.width -= depth * tree_view->priv->expander_size;
2990                 }
2991             }
2992           break;
2993         }
2994
2995       if (column == NULL)
2996         {
2997           gtk_tree_path_free (path);
2998           grab_focus_and_unset_draw_keyfocus (tree_view);
2999           return FALSE;
3000         }
3001
3002       _gtk_tree_view_set_focus_column (tree_view, column);
3003
3004       /* decide if we edit */
3005       if (event->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_PRIMARY &&
3006           !(event->state & gtk_accelerator_get_default_mod_mask ()))
3007         {
3008           GtkTreePath *anchor;
3009           GtkTreeIter iter;
3010
3011           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
3012           gtk_tree_view_column_cell_set_cell_data (column,
3013                                                    tree_view->priv->model,
3014                                                    &iter,
3015                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
3016                                                    node->children?TRUE:FALSE);
3017
3018           if (tree_view->priv->anchor)
3019             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
3020           else
3021             anchor = NULL;
3022
3023           if ((anchor && !gtk_tree_path_compare (anchor, path))
3024               || !_gtk_tree_view_column_has_editable_cell (column))
3025             {
3026               GtkCellEditable *cell_editable = NULL;
3027
3028               /* FIXME: get the right flags */
3029               guint flags = 0;
3030
3031               if (_gtk_tree_view_column_cell_event (column,
3032                                                     (GdkEvent *)event,
3033                                                     &cell_area, flags))
3034                 {
3035                   GtkCellArea *area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
3036                   cell_editable = gtk_cell_area_get_edit_widget (area);
3037
3038                   if (cell_editable != NULL)
3039                     {
3040                       gtk_tree_path_free (path);
3041                       gtk_tree_path_free (anchor);
3042                       return TRUE;
3043                     }
3044                   column_handled_click = TRUE;
3045                 }
3046             }
3047           if (anchor)
3048             gtk_tree_path_free (anchor);
3049         }
3050
3051       extend_mod_mask =
3052         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
3053
3054       modify_mod_mask =
3055         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
3056
3057       /* select */
3058       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
3059       pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3060
3061       /* we only handle selection modifications on the first button press
3062        */
3063       if (event->type == GDK_BUTTON_PRESS)
3064         {
3065           GtkCellRenderer *focus_cell;
3066
3067           if ((event->state & modify_mod_mask) == modify_mod_mask)
3068             tree_view->priv->modify_selection_pressed = TRUE;
3069           if ((event->state & extend_mod_mask) == extend_mod_mask)
3070             tree_view->priv->extend_selection_pressed = TRUE;
3071
3072           /* We update the focus cell here, this is also needed if the
3073            * column does not contain an editable cell.  In this case,
3074            * GtkCellArea did not receive the event for processing (and
3075            * could not update the focus cell).
3076            */
3077           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column,
3078                                                               &cell_area,
3079                                                               &background_area,
3080                                                               event->x,
3081                                                               event->y);
3082
3083           if (focus_cell)
3084             gtk_tree_view_column_focus_cell (column, focus_cell);
3085
3086           if (event->state & modify_mod_mask)
3087             {
3088               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3089               gtk_tree_view_real_toggle_cursor_row (tree_view);
3090             }
3091           else if (event->state & extend_mod_mask)
3092             {
3093               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3094               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
3095             }
3096           else
3097             {
3098               gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
3099             }
3100
3101           tree_view->priv->modify_selection_pressed = FALSE;
3102           tree_view->priv->extend_selection_pressed = FALSE;
3103         }
3104
3105       /* the treeview may have been scrolled because of _set_cursor,
3106        * correct here
3107        */
3108
3109       aft_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3110       dval = pre_val - aft_val;
3111
3112       cell_area.y += dval;
3113       background_area.y += dval;
3114
3115       /* Save press to possibly begin a drag
3116        */
3117       if (!column_handled_click &&
3118           !tree_view->priv->in_grab &&
3119           tree_view->priv->pressed_button < 0)
3120         {
3121           tree_view->priv->pressed_button = event->button;
3122           tree_view->priv->press_start_x = event->x;
3123           tree_view->priv->press_start_y = event->y;
3124
3125           if (tree_view->priv->rubber_banding_enable
3126               && !node_selected
3127               && gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
3128             {
3129               tree_view->priv->press_start_y += tree_view->priv->dy;
3130               tree_view->priv->rubber_band_x = event->x;
3131               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
3132               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
3133
3134               if ((event->state & modify_mod_mask) == modify_mod_mask)
3135                 tree_view->priv->rubber_band_modify = TRUE;
3136               if ((event->state & extend_mod_mask) == extend_mod_mask)
3137                 tree_view->priv->rubber_band_extend = TRUE;
3138             }
3139         }
3140
3141       /* Test if a double click happened on the same row. */
3142       if (event->button == GDK_BUTTON_PRIMARY && event->type == GDK_BUTTON_PRESS)
3143         {
3144           int double_click_time, double_click_distance;
3145
3146           g_object_get (gtk_settings_get_default (),
3147                         "gtk-double-click-time", &double_click_time,
3148                         "gtk-double-click-distance", &double_click_distance,
3149                         NULL);
3150
3151           /* Same conditions as _gdk_event_button_generate */
3152           if (tree_view->priv->last_button_x != -1 &&
3153               (event->time < tree_view->priv->last_button_time + double_click_time) &&
3154               (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
3155               (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
3156             {
3157               /* We do no longer compare paths of this row and the
3158                * row clicked previously.  We use the double click
3159                * distance to decide whether this is a valid click,
3160                * allowing the mouse to slightly move over another row.
3161                */
3162               row_double_click = TRUE;
3163
3164               tree_view->priv->last_button_time = 0;
3165               tree_view->priv->last_button_x = -1;
3166               tree_view->priv->last_button_y = -1;
3167             }
3168           else
3169             {
3170               tree_view->priv->last_button_time = event->time;
3171               tree_view->priv->last_button_x = event->x;
3172               tree_view->priv->last_button_y = event->y;
3173             }
3174         }
3175
3176       if (row_double_click)
3177         {
3178           gtk_grab_remove (widget);
3179           gtk_tree_view_row_activated (tree_view, path, column);
3180
3181           if (tree_view->priv->pressed_button == event->button)
3182             tree_view->priv->pressed_button = -1;
3183         }
3184
3185       gtk_tree_path_free (path);
3186
3187       /* If we activated the row through a double click we don't want to grab
3188        * focus back, as moving focus to another widget is pretty common.
3189        */
3190       if (!row_double_click)
3191         grab_focus_and_unset_draw_keyfocus (tree_view);
3192
3193       return TRUE;
3194     }
3195
3196   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
3197    */
3198   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
3199     {
3200       column = list->data;
3201       if (event->window == _gtk_tree_view_column_get_window (column) &&
3202           gtk_tree_view_column_get_resizable (column) &&
3203           _gtk_tree_view_column_get_window (column))
3204         {
3205           gpointer drag_data;
3206
3207           if (event->type == GDK_2BUTTON_PRESS &&
3208               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
3209             {
3210               _gtk_tree_view_column_set_use_resized_width (column, FALSE);
3211               _gtk_tree_view_column_autosize (tree_view, column);
3212               return TRUE;
3213             }
3214
3215           if (gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
3216                                _gtk_tree_view_column_get_window (column),
3217                                GDK_OWNERSHIP_NONE,
3218                                FALSE,
3219                                GDK_POINTER_MOTION_HINT_MASK
3220                                 | GDK_BUTTON1_MOTION_MASK
3221                                 | GDK_BUTTON_RELEASE_MASK,
3222                                NULL,
3223                                event->time) != GDK_GRAB_SUCCESS)
3224             return FALSE;
3225
3226           gtk_grab_add (widget);
3227           tree_view->priv->in_column_resize = TRUE;
3228
3229           _gtk_tree_view_column_set_resized_width (column, gtk_tree_view_column_get_width (column) -
3230                                                    tree_view->priv->last_extra_space_per_column);
3231
3232           /* block attached dnd signal handler */
3233           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3234           if (drag_data)
3235             g_signal_handlers_block_matched (widget,
3236                                              G_SIGNAL_MATCH_DATA,
3237                                              0, 0, NULL, NULL,
3238                                              drag_data);
3239
3240           tree_view->priv->drag_pos = i;
3241           tree_view->priv->x_drag = gtk_tree_view_column_get_x_offset (column) + (rtl ? 0 : gtk_tree_view_column_get_width (column));
3242
3243           if (!gtk_widget_has_focus (widget))
3244             gtk_widget_grab_focus (widget);
3245
3246           return TRUE;
3247         }
3248     }
3249   return FALSE;
3250 }
3251
3252 /* GtkWidget::button_release_event helper */
3253 static gboolean
3254 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
3255                                           GdkEventButton *event)
3256 {
3257   GtkTreeView *tree_view;
3258   GtkWidget *button;
3259   GList *l;
3260   gboolean rtl;
3261   GdkDevice *device, *other;
3262
3263   tree_view = GTK_TREE_VIEW (widget);
3264
3265   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
3266   device = gdk_event_get_device ((GdkEvent*)event);
3267   other = gdk_device_get_associated_device (device);
3268   gdk_device_ungrab (device, event->time);
3269   gdk_device_ungrab (other, event->time);
3270
3271   /* Move the button back */
3272   button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3273   g_object_ref (button);
3274   gtk_container_remove (GTK_CONTAINER (tree_view), button);
3275   gtk_widget_set_parent_window (button, tree_view->priv->header_window);
3276   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
3277   g_object_unref (button);
3278   gtk_widget_queue_resize (widget);
3279   if (gtk_tree_view_column_get_resizable (tree_view->priv->drag_column))
3280     {
3281       gdk_window_raise (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3282       gdk_window_show (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3283     }
3284   else
3285     gdk_window_hide (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3286
3287   gtk_widget_grab_focus (button);
3288
3289   if (rtl)
3290     {
3291       if (tree_view->priv->cur_reorder &&
3292           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
3293         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3294                                          tree_view->priv->cur_reorder->right_column);
3295     }
3296   else
3297     {
3298       if (tree_view->priv->cur_reorder &&
3299           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
3300         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3301                                          tree_view->priv->cur_reorder->left_column);
3302     }
3303   tree_view->priv->drag_column = NULL;
3304   gdk_window_hide (tree_view->priv->drag_window);
3305
3306   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
3307     g_slice_free (GtkTreeViewColumnReorder, l->data);
3308   g_list_free (tree_view->priv->column_drag_info);
3309   tree_view->priv->column_drag_info = NULL;
3310   tree_view->priv->cur_reorder = NULL;
3311
3312   if (tree_view->priv->drag_highlight_window)
3313     gdk_window_hide (tree_view->priv->drag_highlight_window);
3314
3315   /* Reset our flags */
3316   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
3317   tree_view->priv->in_column_drag = FALSE;
3318
3319   return TRUE;
3320 }
3321
3322 /* GtkWidget::button_release_event helper */
3323 static gboolean
3324 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
3325                                             GdkEventButton *event)
3326 {
3327   GtkTreeView *tree_view;
3328   gpointer drag_data;
3329
3330   tree_view = GTK_TREE_VIEW (widget);
3331
3332   tree_view->priv->drag_pos = -1;
3333
3334   /* unblock attached dnd signal handler */
3335   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3336   if (drag_data)
3337     g_signal_handlers_unblock_matched (widget,
3338                                        G_SIGNAL_MATCH_DATA,
3339                                        0, 0, NULL, NULL,
3340                                        drag_data);
3341
3342   tree_view->priv->in_column_resize = FALSE;
3343   gtk_grab_remove (widget);
3344   gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
3345   return TRUE;
3346 }
3347
3348 static gboolean
3349 gtk_tree_view_button_release (GtkWidget      *widget,
3350                               GdkEventButton *event)
3351 {
3352   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3353
3354   if (tree_view->priv->in_column_drag)
3355     return gtk_tree_view_button_release_drag_column (widget, event);
3356
3357   if (tree_view->priv->rubber_band_status)
3358     gtk_tree_view_stop_rubber_band (tree_view);
3359
3360   if (tree_view->priv->pressed_button == event->button)
3361     tree_view->priv->pressed_button = -1;
3362
3363   if (tree_view->priv->in_column_resize)
3364     return gtk_tree_view_button_release_column_resize (widget, event);
3365
3366   if (tree_view->priv->button_pressed_node == NULL)
3367     return FALSE;
3368
3369   if (event->button == GDK_BUTTON_PRIMARY)
3370     {
3371       if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
3372           tree_view->priv->arrow_prelit)
3373         {
3374           GtkTreePath *path = NULL;
3375
3376           path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
3377                                                  tree_view->priv->button_pressed_node);
3378           /* Actually activate the node */
3379           if (tree_view->priv->button_pressed_node->children == NULL)
3380             gtk_tree_view_real_expand_row (tree_view, path,
3381                                            tree_view->priv->button_pressed_tree,
3382                                            tree_view->priv->button_pressed_node,
3383                                            FALSE, TRUE);
3384           else
3385             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3386                                              tree_view->priv->button_pressed_tree,
3387                                              tree_view->priv->button_pressed_node, TRUE);
3388           gtk_tree_path_free (path);
3389         }
3390
3391       gtk_grab_remove (widget);
3392       tree_view->priv->button_pressed_tree = NULL;
3393       tree_view->priv->button_pressed_node = NULL;
3394     }
3395
3396   return TRUE;
3397 }
3398
3399 static gboolean
3400 gtk_tree_view_grab_broken (GtkWidget          *widget,
3401                            GdkEventGrabBroken *event)
3402 {
3403   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3404
3405   if (tree_view->priv->in_column_drag)
3406     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3407
3408   if (tree_view->priv->in_column_resize)
3409     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3410
3411   return TRUE;
3412 }
3413
3414 #if 0
3415 static gboolean
3416 gtk_tree_view_configure (GtkWidget *widget,
3417                          GdkEventConfigure *event)
3418 {
3419   GtkTreeView *tree_view;
3420
3421   tree_view = GTK_TREE_VIEW (widget);
3422   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3423
3424   return FALSE;
3425 }
3426 #endif
3427
3428 /* GtkWidget::motion_event function set.
3429  */
3430
3431 static gboolean
3432 coords_are_over_arrow (GtkTreeView *tree_view,
3433                        GtkRBTree   *tree,
3434                        GtkRBNode   *node,
3435                        /* these are in bin window coords */
3436                        gint         x,
3437                        gint         y)
3438 {
3439   GdkRectangle arrow;
3440   gint x2;
3441
3442   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
3443     return FALSE;
3444
3445   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3446     return FALSE;
3447
3448   arrow.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
3449   arrow.height = gtk_tree_view_get_row_height (tree_view, node);
3450
3451   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3452
3453   arrow.width = x2 - arrow.x;
3454
3455   return (x >= arrow.x &&
3456           x < (arrow.x + arrow.width) &&
3457           y >= arrow.y &&
3458           y < (arrow.y + arrow.height));
3459 }
3460
3461 static gboolean
3462 auto_expand_timeout (gpointer data)
3463 {
3464   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3465   GtkTreePath *path;
3466
3467   if (tree_view->priv->prelight_node)
3468     {
3469       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->prelight_tree,
3470                                              tree_view->priv->prelight_node);
3471
3472       if (tree_view->priv->prelight_node->children)
3473         gtk_tree_view_collapse_row (tree_view, path);
3474       else
3475         gtk_tree_view_expand_row (tree_view, path, FALSE);
3476
3477       gtk_tree_path_free (path);
3478     }
3479
3480   tree_view->priv->auto_expand_timeout = 0;
3481
3482   return FALSE;
3483 }
3484
3485 static void
3486 remove_auto_expand_timeout (GtkTreeView *tree_view)
3487 {
3488   if (tree_view->priv->auto_expand_timeout != 0)
3489     {
3490       g_source_remove (tree_view->priv->auto_expand_timeout);
3491       tree_view->priv->auto_expand_timeout = 0;
3492     }
3493 }
3494
3495 static void
3496 do_prelight (GtkTreeView *tree_view,
3497              GtkRBTree   *tree,
3498              GtkRBNode   *node,
3499              /* these are in bin_window coords */
3500              gint         x,
3501              gint         y)
3502 {
3503   if (tree_view->priv->prelight_tree == tree &&
3504       tree_view->priv->prelight_node == node)
3505     {
3506       /*  We are still on the same node,
3507           but we might need to take care of the arrow  */
3508
3509       if (tree && node && gtk_tree_view_draw_expanders (tree_view))
3510         {
3511           gboolean over_arrow;
3512
3513           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3514
3515           if (over_arrow != tree_view->priv->arrow_prelit)
3516             {
3517               if (over_arrow)
3518                 tree_view->priv->arrow_prelit = TRUE;
3519               else
3520                 tree_view->priv->arrow_prelit = FALSE;
3521
3522               gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3523             }
3524         }
3525
3526       return;
3527     }
3528
3529   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3530     {
3531       /*  Unprelight the old node and arrow  */
3532
3533       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3534                              GTK_RBNODE_IS_PRELIT);
3535
3536       if (tree_view->priv->arrow_prelit
3537           && gtk_tree_view_draw_expanders (tree_view))
3538         {
3539           tree_view->priv->arrow_prelit = FALSE;
3540
3541           gtk_tree_view_queue_draw_arrow (tree_view,
3542                                           tree_view->priv->prelight_tree,
3543                                           tree_view->priv->prelight_node);
3544         }
3545
3546       _gtk_tree_view_queue_draw_node (tree_view,
3547                                       tree_view->priv->prelight_tree,
3548                                       tree_view->priv->prelight_node,
3549                                       NULL);
3550     }
3551
3552
3553   if (tree_view->priv->hover_expand)
3554     remove_auto_expand_timeout (tree_view);
3555
3556   /*  Set the new prelight values  */
3557   tree_view->priv->prelight_node = node;
3558   tree_view->priv->prelight_tree = tree;
3559
3560   if (!node || !tree)
3561     return;
3562
3563   /*  Prelight the new node and arrow  */
3564
3565   if (gtk_tree_view_draw_expanders (tree_view)
3566       && coords_are_over_arrow (tree_view, tree, node, x, y))
3567     {
3568       tree_view->priv->arrow_prelit = TRUE;
3569
3570       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3571     }
3572
3573   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3574
3575   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3576
3577   if (tree_view->priv->hover_expand)
3578     {
3579       tree_view->priv->auto_expand_timeout =
3580         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3581     }
3582 }
3583
3584 static void
3585 prelight_or_select (GtkTreeView *tree_view,
3586                     GtkRBTree   *tree,
3587                     GtkRBNode   *node,
3588                     /* these are in bin_window coords */
3589                     gint         x,
3590                     gint         y)
3591 {
3592   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3593
3594   if (tree_view->priv->hover_selection &&
3595       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3596       !(tree_view->priv->edited_column &&
3597         gtk_cell_area_get_edit_widget
3598         (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column)))))
3599     {
3600       if (node)
3601         {
3602           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3603             {
3604               GtkTreePath *path;
3605
3606               path = _gtk_tree_path_new_from_rbtree (tree, node);
3607               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3608               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3609                 {
3610                   tree_view->priv->draw_keyfocus = FALSE;
3611                   gtk_tree_view_real_set_cursor (tree_view, path, 0);
3612                 }
3613               gtk_tree_path_free (path);
3614             }
3615         }
3616
3617       else if (mode == GTK_SELECTION_SINGLE)
3618         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3619     }
3620
3621     do_prelight (tree_view, tree, node, x, y);
3622 }
3623
3624 static void
3625 ensure_unprelighted (GtkTreeView *tree_view)
3626 {
3627   do_prelight (tree_view,
3628                NULL, NULL,
3629                -1000, -1000); /* coords not possibly over an arrow */
3630
3631   g_assert (tree_view->priv->prelight_node == NULL);
3632 }
3633
3634 static void
3635 update_prelight (GtkTreeView *tree_view,
3636                  gint         x,
3637                  gint         y)
3638 {
3639   int new_y;
3640   GtkRBTree *tree;
3641   GtkRBNode *node;
3642
3643   if (tree_view->priv->tree == NULL)
3644     return;
3645
3646   if (x == -10000)
3647     {
3648       ensure_unprelighted (tree_view);
3649       return;
3650     }
3651
3652   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
3653   if (new_y < 0)
3654     new_y = 0;
3655
3656   _gtk_rbtree_find_offset (tree_view->priv->tree,
3657                            new_y, &tree, &node);
3658
3659   if (node)
3660     prelight_or_select (tree_view, tree, node, x, y);
3661 }
3662
3663
3664
3665
3666 /* Our motion arrow is either a box (in the case of the original spot)
3667  * or an arrow.  It is expander_size wide.
3668  */
3669 /*
3670  * 11111111111111
3671  * 01111111111110
3672  * 00111111111100
3673  * 00011111111000
3674  * 00001111110000
3675  * 00000111100000
3676  * 00000111100000
3677  * 00000111100000
3678  * ~ ~ ~ ~ ~ ~ ~
3679  * 00000111100000
3680  * 00000111100000
3681  * 00000111100000
3682  * 00001111110000
3683  * 00011111111000
3684  * 00111111111100
3685  * 01111111111110
3686  * 11111111111111
3687  */
3688
3689 static void
3690 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3691 {
3692   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3693   GtkWidget *widget = GTK_WIDGET (tree_view);
3694   cairo_surface_t *mask_image;
3695   cairo_region_t *mask_region;
3696   gint x;
3697   gint y;
3698   gint width;
3699   gint height;
3700   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3701   GdkWindowAttr attributes;
3702   guint attributes_mask;
3703   cairo_t *cr;
3704
3705   if (!reorder ||
3706       reorder->left_column == tree_view->priv->drag_column ||
3707       reorder->right_column == tree_view->priv->drag_column)
3708     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3709   else if (reorder->left_column || reorder->right_column)
3710     {
3711       GtkAllocation left_allocation, right_allocation;
3712       GdkRectangle visible_rect;
3713       GtkWidget *button;
3714
3715       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3716       if (reorder->left_column)
3717         {
3718           button = gtk_tree_view_column_get_button (reorder->left_column);
3719           gtk_widget_get_allocation (button, &left_allocation);
3720           x = left_allocation.x + left_allocation.width;
3721         }
3722       else
3723         {
3724           button = gtk_tree_view_column_get_button (reorder->right_column);
3725           gtk_widget_get_allocation (button, &right_allocation);
3726           x = right_allocation.x;
3727         }
3728
3729       if (x < visible_rect.x)
3730         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3731       else if (x > visible_rect.x + visible_rect.width)
3732         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3733       else
3734         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3735     }
3736
3737   /* We want to draw the rectangle over the initial location. */
3738   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3739     {
3740       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3741         {
3742           GtkAllocation drag_allocation;
3743           GtkWidget    *button;
3744
3745           if (tree_view->priv->drag_highlight_window)
3746             {
3747               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3748                                         NULL);
3749               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3750             }
3751
3752           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3753           attributes.window_type = GDK_WINDOW_CHILD;
3754           attributes.wclass = GDK_INPUT_OUTPUT;
3755           attributes.x = tree_view->priv->drag_column_x;
3756           attributes.y = 0;
3757           gtk_widget_get_allocation (button, &drag_allocation);
3758           width = attributes.width = drag_allocation.width;
3759           height = attributes.height = drag_allocation.height;
3760           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3761           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3762           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3763           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3764           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3765
3766           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3767           cr = cairo_create (mask_image);
3768
3769           cairo_rectangle (cr, 1, 1, width - 2, height - 2);
3770           cairo_stroke (cr);
3771           cairo_destroy (cr);
3772
3773           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3774           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3775                                            mask_region, 0, 0);
3776
3777           cairo_region_destroy (mask_region);
3778           cairo_surface_destroy (mask_image);
3779
3780           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3781         }
3782     }
3783   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3784     {
3785       GtkAllocation button_allocation;
3786       GtkWidget    *button;
3787
3788       width = tree_view->priv->expander_size;
3789
3790       /* Get x, y, width, height of arrow */
3791       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3792       if (reorder->left_column)
3793         {
3794           button = gtk_tree_view_column_get_button (reorder->left_column);
3795           gtk_widget_get_allocation (button, &button_allocation);
3796           x += button_allocation.x + button_allocation.width - width/2;
3797           height = button_allocation.height;
3798         }
3799       else
3800         {
3801           button = gtk_tree_view_column_get_button (reorder->right_column);
3802           gtk_widget_get_allocation (button, &button_allocation);
3803           x += button_allocation.x - width/2;
3804           height = button_allocation.height;
3805         }
3806       y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */
3807       height += tree_view->priv->expander_size;
3808
3809       /* Create the new window */
3810       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3811         {
3812           if (tree_view->priv->drag_highlight_window)
3813             {
3814               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3815                                         NULL);
3816               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3817             }
3818
3819           attributes.window_type = GDK_WINDOW_TEMP;
3820           attributes.wclass = GDK_INPUT_OUTPUT;
3821           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3822           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3823           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3824           attributes.x = x;
3825           attributes.y = y;
3826           attributes.width = width;
3827           attributes.height = height;
3828           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3829                                                                    &attributes, attributes_mask);
3830           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3831
3832           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3833
3834           cr = cairo_create (mask_image);
3835           cairo_move_to (cr, 0, 0);
3836           cairo_line_to (cr, width, 0);
3837           cairo_line_to (cr, width / 2., width / 2);
3838           cairo_move_to (cr, 0, height);
3839           cairo_line_to (cr, width, height);
3840           cairo_line_to (cr, width / 2., height - width / 2.);
3841           cairo_fill (cr);
3842           cairo_destroy (cr);
3843
3844           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3845           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3846                                            mask_region, 0, 0);
3847
3848           cairo_region_destroy (mask_region);
3849           cairo_surface_destroy (mask_image);
3850         }
3851
3852       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3853       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3854     }
3855   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3856            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3857     {
3858       GtkAllocation allocation;
3859       GtkWidget    *button;
3860
3861       width = tree_view->priv->expander_size;
3862
3863       /* Get x, y, width, height of arrow */
3864       width = width/2; /* remember, the arrow only takes half the available width */
3865       gdk_window_get_origin (gtk_widget_get_window (widget),
3866                              &x, &y);
3867       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3868         {
3869           gtk_widget_get_allocation (widget, &allocation);
3870           x += allocation.width - width;
3871         }
3872
3873       if (reorder->left_column)
3874         {
3875           button = gtk_tree_view_column_get_button (reorder->left_column);
3876           gtk_widget_get_allocation (button, &allocation);
3877           height = allocation.height;
3878         }
3879       else
3880         {
3881           button = gtk_tree_view_column_get_button (reorder->right_column);
3882           gtk_widget_get_allocation (button, &allocation);
3883           height = allocation.height;
3884         }
3885
3886       y -= tree_view->priv->expander_size;
3887       height += 2*tree_view->priv->expander_size;
3888
3889       /* Create the new window */
3890       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3891           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3892         {
3893           if (tree_view->priv->drag_highlight_window)
3894             {
3895               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3896                                         NULL);
3897               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3898             }
3899
3900           attributes.window_type = GDK_WINDOW_TEMP;
3901           attributes.wclass = GDK_INPUT_OUTPUT;
3902           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3903           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3904           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3905           attributes.x = x;
3906           attributes.y = y;
3907           attributes.width = width;
3908           attributes.height = height;
3909           tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
3910           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3911
3912           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3913
3914           cr = cairo_create (mask_image);
3915           /* mirror if we're on the left */
3916           if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3917             {
3918               cairo_translate (cr, width, 0);
3919               cairo_scale (cr, -1, 1);
3920             }
3921           cairo_move_to (cr, 0, 0);
3922           cairo_line_to (cr, width, width);
3923           cairo_line_to (cr, 0, tree_view->priv->expander_size);
3924           cairo_move_to (cr, 0, height);
3925           cairo_line_to (cr, width, height - width);
3926           cairo_line_to (cr, 0, height - tree_view->priv->expander_size);
3927           cairo_fill (cr);
3928           cairo_destroy (cr);
3929
3930           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3931           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3932                                            mask_region, 0, 0);
3933
3934           cairo_region_destroy (mask_region);
3935           cairo_surface_destroy (mask_image);
3936         }
3937
3938       tree_view->priv->drag_column_window_state = arrow_type;
3939       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3940    }
3941   else
3942     {
3943       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
3944       gdk_window_hide (tree_view->priv->drag_highlight_window);
3945       return;
3946     }
3947
3948   gdk_window_show (tree_view->priv->drag_highlight_window);
3949   gdk_window_raise (tree_view->priv->drag_highlight_window);
3950 }
3951
3952 static gboolean
3953 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
3954                                     GdkEventMotion *event)
3955 {
3956   gint x;
3957   gint new_width;
3958   GtkTreeViewColumn *column;
3959   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3960
3961   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
3962
3963   if (event->is_hint || event->window != gtk_widget_get_window (widget))
3964     gdk_window_get_device_position (gtk_widget_get_window (widget),
3965                                     gdk_event_get_device ((GdkEvent *) event),
3966                                     &x, NULL, NULL);
3967   else
3968     x = event->x;
3969
3970   if (tree_view->priv->hadjustment)
3971     x += gtk_adjustment_get_value (tree_view->priv->hadjustment);
3972
3973   new_width = gtk_tree_view_new_column_width (tree_view,
3974                                               tree_view->priv->drag_pos, &x);
3975   if (x != tree_view->priv->x_drag &&
3976       (new_width != gtk_tree_view_column_get_fixed_width (column)))
3977     {
3978       _gtk_tree_view_column_set_use_resized_width (column, TRUE);
3979
3980       if (gtk_tree_view_column_get_expand (column))
3981         new_width -= tree_view->priv->last_extra_space_per_column;
3982
3983       _gtk_tree_view_column_set_resized_width (column, new_width);
3984
3985
3986       gtk_widget_queue_resize (widget);
3987     }
3988
3989   return FALSE;
3990 }
3991
3992
3993 static void
3994 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view,
3995                                       GdkEvent    *event)
3996 {
3997   GtkTreeViewColumnReorder *reorder = NULL;
3998   GList *list;
3999   gint mouse_x;
4000
4001   gdk_window_get_device_position (tree_view->priv->header_window,
4002                                   gdk_event_get_device (event),
4003                                   &mouse_x, NULL, NULL);
4004   for (list = tree_view->priv->column_drag_info; list; list = list->next)
4005     {
4006       reorder = (GtkTreeViewColumnReorder *) list->data;
4007       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
4008         break;
4009       reorder = NULL;
4010     }
4011
4012   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
4013       return;*/
4014
4015   tree_view->priv->cur_reorder = reorder;
4016   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
4017 }
4018
4019 static void
4020 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
4021 {
4022   GdkRectangle visible_rect;
4023   gint y;
4024   gint offset;
4025
4026   gdk_window_get_device_position (tree_view->priv->bin_window,
4027                                   gdk_device_manager_get_client_pointer (
4028                                     gdk_display_get_device_manager (
4029                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4030                                   NULL, &y, NULL);
4031   y += tree_view->priv->dy;
4032
4033   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4034
4035   /* see if we are near the edge. */
4036   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
4037   if (offset > 0)
4038     {
4039       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
4040       if (offset < 0)
4041         return;
4042     }
4043
4044   gtk_adjustment_set_value (tree_view->priv->vadjustment,
4045                             MAX (gtk_adjustment_get_value (tree_view->priv->vadjustment) + offset, 0.0));
4046 }
4047
4048 static gboolean
4049 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view,
4050                                      GdkEvent    *event)
4051 {
4052   GdkRectangle visible_rect;
4053   gint x;
4054   gint offset;
4055
4056   gdk_window_get_device_position (tree_view->priv->bin_window,
4057                                   gdk_event_get_device (event),
4058                                   &x, NULL, NULL);
4059
4060   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4061
4062   /* See if we are near the edge. */
4063   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
4064   if (offset > 0)
4065     {
4066       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
4067       if (offset < 0)
4068         return TRUE;
4069     }
4070   offset = offset/3;
4071
4072   gtk_adjustment_set_value (tree_view->priv->hadjustment,
4073                             MAX (gtk_adjustment_get_value (tree_view->priv->hadjustment) + offset, 0.0));
4074
4075   return TRUE;
4076
4077 }
4078
4079 static gboolean
4080 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
4081                                   GdkEventMotion *event)
4082 {
4083   GtkAllocation allocation, button_allocation;
4084   GtkTreeView *tree_view = (GtkTreeView *) widget;
4085   GtkTreeViewColumn *column = tree_view->priv->drag_column;
4086   GtkWidget *button;
4087   gint x, y;
4088
4089   /* Sanity Check */
4090   if ((column == NULL) ||
4091       (event->window != tree_view->priv->drag_window))
4092     return FALSE;
4093
4094   button = gtk_tree_view_column_get_button (column);
4095
4096   /* Handle moving the header */
4097   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
4098   gtk_widget_get_allocation (widget, &allocation);
4099   gtk_widget_get_allocation (button, &button_allocation);
4100   x = CLAMP (x + (gint)event->x - _gtk_tree_view_column_get_drag_x (column), 0,
4101              MAX (tree_view->priv->width, allocation.width) - button_allocation.width);
4102   gdk_window_move (tree_view->priv->drag_window, x, y);
4103
4104   /* autoscroll, if needed */
4105   gtk_tree_view_horizontal_autoscroll (tree_view, (GdkEvent *) event);
4106   /* Update the current reorder position and arrow; */
4107   gtk_tree_view_update_current_reorder (tree_view, (GdkEvent *) event);
4108
4109   return TRUE;
4110 }
4111
4112 static void
4113 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
4114 {
4115   remove_scroll_timeout (tree_view);
4116   gtk_grab_remove (GTK_WIDGET (tree_view));
4117
4118   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4119     {
4120       GtkTreePath *tmp_path;
4121
4122       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4123
4124       /* The anchor path should be set to the start path */
4125       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_start_tree,
4126                                                  tree_view->priv->rubber_band_start_node);
4127
4128       if (tree_view->priv->anchor)
4129         gtk_tree_row_reference_free (tree_view->priv->anchor);
4130
4131       tree_view->priv->anchor =
4132         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
4133                                           tree_view->priv->model,
4134                                           tmp_path);
4135
4136       gtk_tree_path_free (tmp_path);
4137
4138       /* ... and the cursor to the end path */
4139       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_end_tree,
4140                                                  tree_view->priv->rubber_band_end_node);
4141       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, 0);
4142       gtk_tree_path_free (tmp_path);
4143
4144       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
4145     }
4146
4147   /* Clear status variables */
4148   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
4149   tree_view->priv->rubber_band_extend = FALSE;
4150   tree_view->priv->rubber_band_modify = FALSE;
4151
4152   tree_view->priv->rubber_band_start_node = NULL;
4153   tree_view->priv->rubber_band_start_tree = NULL;
4154   tree_view->priv->rubber_band_end_node = NULL;
4155   tree_view->priv->rubber_band_end_tree = NULL;
4156 }
4157
4158 static void
4159 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
4160                                                  GtkRBTree   *start_tree,
4161                                                  GtkRBNode   *start_node,
4162                                                  GtkRBTree   *end_tree,
4163                                                  GtkRBNode   *end_node,
4164                                                  gboolean     select,
4165                                                  gboolean     skip_start,
4166                                                  gboolean     skip_end)
4167 {
4168   if (start_node == end_node)
4169     return;
4170
4171   /* We skip the first node and jump inside the loop */
4172   if (skip_start)
4173     goto skip_first;
4174
4175   do
4176     {
4177       /* Small optimization by assuming insensitive nodes are never
4178        * selected.
4179        */
4180       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4181         {
4182           GtkTreePath *path;
4183           gboolean selectable;
4184
4185           path = _gtk_tree_path_new_from_rbtree (start_tree, start_node);
4186           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
4187           gtk_tree_path_free (path);
4188
4189           if (!selectable)
4190             goto node_not_selectable;
4191         }
4192
4193       if (select)
4194         {
4195           if (tree_view->priv->rubber_band_extend)
4196             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4197           else if (tree_view->priv->rubber_band_modify)
4198             {
4199               /* Toggle the selection state */
4200               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4201                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4202               else
4203                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4204             }
4205           else
4206             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4207         }
4208       else
4209         {
4210           /* Mirror the above */
4211           if (tree_view->priv->rubber_band_extend)
4212             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4213           else if (tree_view->priv->rubber_band_modify)
4214             {
4215               /* Toggle the selection state */
4216               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4217                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4218               else
4219                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4220             }
4221           else
4222             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4223         }
4224
4225       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
4226
4227 node_not_selectable:
4228       if (start_node == end_node)
4229         break;
4230
4231 skip_first:
4232
4233       if (start_node->children)
4234         {
4235           start_tree = start_node->children;
4236           start_node = _gtk_rbtree_first (start_tree);
4237         }
4238       else
4239         {
4240           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
4241
4242           if (!start_tree)
4243             /* Ran out of tree */
4244             break;
4245         }
4246
4247       if (skip_end && start_node == end_node)
4248         break;
4249     }
4250   while (TRUE);
4251 }
4252
4253 static void
4254 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
4255 {
4256   GtkRBTree *start_tree, *end_tree;
4257   GtkRBNode *start_node, *end_node;
4258
4259   _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);
4260   _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);
4261
4262   /* Handle the start area first */
4263   if (!tree_view->priv->rubber_band_start_node)
4264     {
4265       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4266                                                        start_tree,
4267                                                        start_node,
4268                                                        end_tree,
4269                                                        end_node,
4270                                                        TRUE,
4271                                                        FALSE,
4272                                                        FALSE);
4273     }
4274   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
4275            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4276     {
4277       /* New node is above the old one; selection became bigger */
4278       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4279                                                        start_tree,
4280                                                        start_node,
4281                                                        tree_view->priv->rubber_band_start_tree,
4282                                                        tree_view->priv->rubber_band_start_node,
4283                                                        TRUE,
4284                                                        FALSE,
4285                                                        TRUE);
4286     }
4287   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
4288            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4289     {
4290       /* New node is below the old one; selection became smaller */
4291       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4292                                                        tree_view->priv->rubber_band_start_tree,
4293                                                        tree_view->priv->rubber_band_start_node,
4294                                                        start_tree,
4295                                                        start_node,
4296                                                        FALSE,
4297                                                        FALSE,
4298                                                        TRUE);
4299     }
4300
4301   tree_view->priv->rubber_band_start_tree = start_tree;
4302   tree_view->priv->rubber_band_start_node = start_node;
4303
4304   /* Next, handle the end area */
4305   if (!tree_view->priv->rubber_band_end_node)
4306     {
4307       /* In the event this happens, start_node was also NULL; this case is
4308        * handled above.
4309        */
4310     }
4311   else if (!end_node)
4312     {
4313       /* Find the last node in the tree */
4314       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
4315                                &end_tree, &end_node);
4316
4317       /* Selection reached end of the tree */
4318       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4319                                                        tree_view->priv->rubber_band_end_tree,
4320                                                        tree_view->priv->rubber_band_end_node,
4321                                                        end_tree,
4322                                                        end_node,
4323                                                        TRUE,
4324                                                        TRUE,
4325                                                        FALSE);
4326     }
4327   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
4328            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4329     {
4330       /* New node is below the old one; selection became bigger */
4331       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4332                                                        tree_view->priv->rubber_band_end_tree,
4333                                                        tree_view->priv->rubber_band_end_node,
4334                                                        end_tree,
4335                                                        end_node,
4336                                                        TRUE,
4337                                                        TRUE,
4338                                                        FALSE);
4339     }
4340   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
4341            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4342     {
4343       /* New node is above the old one; selection became smaller */
4344       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4345                                                        end_tree,
4346                                                        end_node,
4347                                                        tree_view->priv->rubber_band_end_tree,
4348                                                        tree_view->priv->rubber_band_end_node,
4349                                                        FALSE,
4350                                                        TRUE,
4351                                                        FALSE);
4352     }
4353
4354   tree_view->priv->rubber_band_end_tree = end_tree;
4355   tree_view->priv->rubber_band_end_node = end_node;
4356 }
4357
4358 static void
4359 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
4360 {
4361   gint x, y;
4362   GdkRectangle old_area;
4363   GdkRectangle new_area;
4364   GdkRectangle common;
4365   cairo_region_t *invalid_region;
4366
4367   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4368   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4369   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
4370   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
4371
4372   gdk_window_get_device_position (tree_view->priv->bin_window,
4373                                   gdk_device_manager_get_client_pointer (
4374                                     gdk_display_get_device_manager (
4375                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4376                                   &x, &y, NULL);
4377
4378   x = MAX (x, 0);
4379   y = MAX (y, 0) + tree_view->priv->dy;
4380
4381   new_area.x = MIN (tree_view->priv->press_start_x, x);
4382   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
4383   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
4384   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
4385
4386   invalid_region = cairo_region_create_rectangle (&old_area);
4387   cairo_region_union_rectangle (invalid_region, &new_area);
4388
4389   gdk_rectangle_intersect (&old_area, &new_area, &common);
4390   if (common.width > 2 && common.height > 2)
4391     {
4392       cairo_region_t *common_region;
4393
4394       /* make sure the border is invalidated */
4395       common.x += 1;
4396       common.y += 1;
4397       common.width -= 2;
4398       common.height -= 2;
4399
4400       common_region = cairo_region_create_rectangle (&common);
4401
4402       cairo_region_subtract (invalid_region, common_region);
4403       cairo_region_destroy (common_region);
4404     }
4405
4406   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
4407
4408   cairo_region_destroy (invalid_region);
4409
4410   tree_view->priv->rubber_band_x = x;
4411   tree_view->priv->rubber_band_y = y;
4412
4413   gtk_tree_view_update_rubber_band_selection (tree_view);
4414 }
4415
4416 static void
4417 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4418                                  cairo_t      *cr)
4419 {
4420   GdkRectangle rect;
4421   GtkStyleContext *context;
4422
4423   cairo_save (cr);
4424
4425   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4426
4427   gtk_style_context_save (context);
4428   gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND);
4429
4430   rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4431   rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4432   rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4433   rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4434
4435   gdk_cairo_rectangle (cr, &rect);
4436   cairo_clip (cr);
4437
4438   gtk_render_background (context, cr,
4439                          rect.x, rect.y,
4440                          rect.width, rect.height);
4441   gtk_render_frame (context, cr,
4442                     rect.x, rect.y,
4443                     rect.width, rect.height);
4444
4445   gtk_style_context_restore (context);
4446   cairo_restore (cr);
4447 }
4448
4449 static gboolean
4450 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4451                                  GdkEventMotion *event)
4452 {
4453   GtkTreeView *tree_view;
4454   GtkRBTree *tree;
4455   GtkRBNode *node;
4456   gint new_y;
4457
4458   tree_view = (GtkTreeView *) widget;
4459
4460   if (tree_view->priv->tree == NULL)
4461     return FALSE;
4462
4463   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4464     {
4465       gtk_grab_add (GTK_WIDGET (tree_view));
4466       gtk_tree_view_update_rubber_band (tree_view);
4467
4468       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4469     }
4470   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4471     {
4472       gtk_tree_view_update_rubber_band (tree_view);
4473
4474       add_scroll_timeout (tree_view);
4475     }
4476
4477   /* only check for an initiated drag when a button is pressed */
4478   if (tree_view->priv->pressed_button >= 0
4479       && !tree_view->priv->rubber_band_status)
4480     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4481
4482   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4483   if (new_y < 0)
4484     new_y = 0;
4485
4486   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4487
4488   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4489   if ((tree_view->priv->button_pressed_node != NULL) &&
4490       (tree_view->priv->button_pressed_node != node))
4491     node = NULL;
4492
4493   tree_view->priv->event_last_x = event->x;
4494   tree_view->priv->event_last_y = event->y;
4495
4496   prelight_or_select (tree_view, tree, node, event->x, event->y);
4497
4498   return TRUE;
4499 }
4500
4501 static gboolean
4502 gtk_tree_view_motion (GtkWidget      *widget,
4503                       GdkEventMotion *event)
4504 {
4505   GtkTreeView *tree_view;
4506
4507   tree_view = (GtkTreeView *) widget;
4508
4509   /* Resizing a column */
4510   if (tree_view->priv->in_column_resize)
4511     return gtk_tree_view_motion_resize_column (widget, event);
4512
4513   /* Drag column */
4514   if (tree_view->priv->in_column_drag)
4515     return gtk_tree_view_motion_drag_column (widget, event);
4516
4517   /* Sanity check it */
4518   if (event->window == tree_view->priv->bin_window)
4519     return gtk_tree_view_motion_bin_window (widget, event);
4520
4521   return FALSE;
4522 }
4523
4524 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4525  * the tree is empty.
4526  */
4527 static void
4528 invalidate_empty_focus (GtkTreeView *tree_view)
4529 {
4530   GdkRectangle area;
4531
4532   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
4533     return;
4534
4535   area.x = 0;
4536   area.y = 0;
4537   area.width = gdk_window_get_width (tree_view->priv->bin_window);
4538   area.height = gdk_window_get_height (tree_view->priv->bin_window);
4539   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4540 }
4541
4542 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4543  * is empty.
4544  */
4545 static void
4546 draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr)
4547 {
4548   GtkWidget *widget = GTK_WIDGET (tree_view);
4549   gint w, h;
4550
4551   if (!gtk_widget_has_visible_focus (widget))
4552     return;
4553
4554   w = gdk_window_get_width (tree_view->priv->bin_window) - 2;
4555   h = gdk_window_get_height (tree_view->priv->bin_window) - 2;
4556
4557   if (w > 0 && h > 0)
4558     {
4559       GtkStyleContext *context;
4560
4561       context = gtk_widget_get_style_context (widget);
4562
4563       gtk_render_focus (context, cr, 1, 1, w, h);
4564     }
4565 }
4566
4567 typedef enum {
4568   GTK_TREE_VIEW_GRID_LINE,
4569   GTK_TREE_VIEW_TREE_LINE,
4570   GTK_TREE_VIEW_FOREGROUND_LINE
4571 } GtkTreeViewLineType;
4572
4573 static void
4574 gtk_tree_view_draw_line (GtkTreeView         *tree_view,
4575                          cairo_t             *cr,
4576                          GtkTreeViewLineType  type,
4577                          int                  x1,
4578                          int                  y1,
4579                          int                  x2,
4580                          int                  y2)
4581 {
4582   cairo_save (cr);
4583
4584   switch (type)
4585     {
4586     case GTK_TREE_VIEW_TREE_LINE:
4587       cairo_set_source_rgb (cr, 0, 0, 0);
4588       cairo_set_line_width (cr, tree_view->priv->tree_line_width);
4589       if (tree_view->priv->tree_line_dashes[0])
4590         cairo_set_dash (cr,
4591                         tree_view->priv->tree_line_dashes,
4592                         2, 0.5);
4593       break;
4594     case GTK_TREE_VIEW_GRID_LINE:
4595       cairo_set_source_rgb (cr, 0, 0, 0);
4596       cairo_set_line_width (cr, tree_view->priv->grid_line_width);
4597       if (tree_view->priv->grid_line_dashes[0])
4598         cairo_set_dash (cr,
4599                         tree_view->priv->grid_line_dashes,
4600                         2, 0.5);
4601       break;
4602     default:
4603       g_assert_not_reached ();
4604       /* fall through */
4605     case GTK_TREE_VIEW_FOREGROUND_LINE:
4606       {
4607         GtkStyleContext *context;
4608         GtkStateFlags state;
4609         GdkRGBA color;
4610
4611         context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4612         state = gtk_widget_get_state_flags (GTK_WIDGET (tree_view));
4613
4614         cairo_set_line_width (cr, 1.0);
4615         gtk_style_context_get_color (context, state, &color);
4616         gdk_cairo_set_source_rgba (cr, &color);
4617       }
4618
4619       break;
4620     }
4621
4622   cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
4623   cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
4624   cairo_stroke (cr);
4625
4626   cairo_restore (cr);
4627 }
4628
4629 static void
4630 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4631                                cairo_t        *cr,
4632                                gint            n_visible_columns)
4633 {
4634   GList *list = tree_view->priv->columns;
4635   gint i = 0;
4636   gint current_x = 0;
4637
4638   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4639       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4640     return;
4641
4642   /* Only draw the lines for visible rows and columns */
4643   for (list = tree_view->priv->columns; list; list = list->next, i++)
4644     {
4645       GtkTreeViewColumn *column = list->data;
4646
4647       /* We don't want a line for the last column */
4648       if (i == n_visible_columns - 1)
4649         break;
4650
4651       if (!gtk_tree_view_column_get_visible (column))
4652         continue;
4653
4654       current_x += gtk_tree_view_column_get_width (column);
4655
4656       gtk_tree_view_draw_line (tree_view, cr,
4657                                GTK_TREE_VIEW_GRID_LINE,
4658                                current_x - 1, 0,
4659                                current_x - 1, tree_view->priv->height);
4660     }
4661 }
4662
4663 /* Warning: Very scary function.
4664  * Modify at your own risk
4665  *
4666  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4667  * FIXME: It's not...
4668  */
4669 static gboolean
4670 gtk_tree_view_bin_draw (GtkWidget      *widget,
4671                         cairo_t        *cr)
4672 {
4673   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4674   GtkTreePath *path;
4675   GtkRBTree *tree;
4676   GList *list;
4677   GtkRBNode *node;
4678   GtkRBNode *drag_highlight = NULL;
4679   GtkRBTree *drag_highlight_tree = NULL;
4680   GtkTreeIter iter;
4681   gint new_y;
4682   gint y_offset, cell_offset;
4683   gint max_height;
4684   gint depth;
4685   GdkRectangle background_area;
4686   GdkRectangle cell_area;
4687   GdkRectangle clip;
4688   guint flags;
4689   gint highlight_x;
4690   gint expander_cell_width;
4691   gint bin_window_width;
4692   gint bin_window_height;
4693   GtkTreePath *drag_dest_path;
4694   GList *first_column, *last_column;
4695   gint vertical_separator;
4696   gint horizontal_separator;
4697   gboolean allow_rules;
4698   gboolean has_can_focus_cell;
4699   gboolean rtl;
4700   gint n_visible_columns;
4701   gint grid_line_width;
4702   gboolean draw_vgrid_lines, draw_hgrid_lines;
4703   GtkStyleContext *context;
4704   gboolean parity;
4705
4706   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4707   context = gtk_widget_get_style_context (widget);
4708
4709   gtk_widget_style_get (widget,
4710                         "horizontal-separator", &horizontal_separator,
4711                         "vertical-separator", &vertical_separator,
4712                         "allow-rules", &allow_rules,
4713                         NULL);
4714
4715   if (tree_view->priv->tree == NULL)
4716     {
4717       draw_empty_focus (tree_view, cr);
4718       return TRUE;
4719     }
4720
4721   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
4722   bin_window_height = gdk_window_get_height (tree_view->priv->bin_window);
4723   cairo_rectangle (cr, 0, 0, bin_window_width, bin_window_height);
4724   cairo_clip (cr);
4725   if (!gdk_cairo_get_clip_rectangle (cr, &clip))
4726     return TRUE;
4727
4728   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, clip.y);
4729
4730   if (new_y < 0)
4731     new_y = 0;
4732   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4733
4734   if (tree_view->priv->height < bin_window_height)
4735     {
4736       gtk_style_context_save (context);
4737       gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4738
4739       gtk_render_background (context, cr,
4740                              0, tree_view->priv->height,
4741                              bin_window_width,
4742                              bin_window_height - tree_view->priv->height);
4743
4744       gtk_style_context_restore (context);
4745     }
4746
4747   if (node == NULL)
4748     return TRUE;
4749
4750   /* find the path for the node */
4751   path = _gtk_tree_path_new_from_rbtree (tree, node);
4752   gtk_tree_model_get_iter (tree_view->priv->model,
4753                            &iter,
4754                            path);
4755   depth = gtk_tree_path_get_depth (path);
4756   gtk_tree_path_free (path);
4757
4758   drag_dest_path = NULL;
4759
4760   if (tree_view->priv->drag_dest_row)
4761     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4762
4763   if (drag_dest_path)
4764     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4765                               &drag_highlight_tree, &drag_highlight);
4766
4767   draw_vgrid_lines =
4768     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4769     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4770   draw_hgrid_lines =
4771     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4772     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4773
4774   if (draw_vgrid_lines || draw_hgrid_lines)
4775     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4776
4777   n_visible_columns = 0;
4778   for (list = tree_view->priv->columns; list; list = list->next)
4779     {
4780       if (!gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
4781         continue;
4782       n_visible_columns ++;
4783     }
4784
4785   /* Find the last column */
4786   for (last_column = g_list_last (tree_view->priv->columns);
4787        last_column &&
4788        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
4789        last_column = last_column->prev)
4790     ;
4791
4792   /* and the first */
4793   for (first_column = g_list_first (tree_view->priv->columns);
4794        first_column &&
4795        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
4796        first_column = first_column->next)
4797     ;
4798
4799   /* Actually process the expose event.  To do this, we want to
4800    * start at the first node of the event, and walk the tree in
4801    * order, drawing each successive node.
4802    */
4803
4804   parity = !(_gtk_rbtree_node_get_index (tree, node) % 2);
4805
4806   do
4807     {
4808       gboolean is_separator = FALSE;
4809       gboolean is_first = FALSE;
4810       gboolean is_last = FALSE;
4811       gint n_col = 0;
4812
4813       parity = !parity;
4814       is_separator = row_is_separator (tree_view, &iter, NULL);
4815
4816       max_height = gtk_tree_view_get_row_height (tree_view, node);
4817
4818       cell_offset = 0;
4819       highlight_x = 0; /* should match x coord of first cell */
4820       expander_cell_width = 0;
4821
4822       background_area.y = y_offset + clip.y;
4823       background_area.height = max_height;
4824
4825       flags = 0;
4826
4827       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4828         flags |= GTK_CELL_RENDERER_PRELIT;
4829
4830       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4831         flags |= GTK_CELL_RENDERER_SELECTED;
4832
4833       /* we *need* to set cell data on all cells before the call
4834        * to _has_can_focus_cell, else _has_can_focus_cell() does not
4835        * return a correct value.
4836        */
4837       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4838            list;
4839            list = (rtl ? list->prev : list->next))
4840         {
4841           GtkTreeViewColumn *column = list->data;
4842           gtk_tree_view_column_cell_set_cell_data (column,
4843                                                    tree_view->priv->model,
4844                                                    &iter,
4845                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4846                                                    node->children?TRUE:FALSE);
4847         }
4848
4849       has_can_focus_cell = gtk_tree_view_has_can_focus_cell (tree_view);
4850
4851       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4852            list;
4853            list = (rtl ? list->prev : list->next))
4854         {
4855           GtkTreeViewColumn *column = list->data;
4856           GtkRegionFlags row_flags = 0, column_flags = 0;
4857           GtkStateFlags state = 0;
4858           gint width;
4859           gboolean draw_focus;
4860
4861           if (!gtk_tree_view_column_get_visible (column))
4862             continue;
4863
4864           n_col++;
4865           width = gtk_tree_view_column_get_width (column);
4866
4867           if (cell_offset > clip.x + clip.width ||
4868               cell_offset + width < clip.x)
4869             {
4870               cell_offset += width;
4871               continue;
4872             }
4873
4874           if (gtk_tree_view_column_get_sort_indicator (column))
4875             flags |= GTK_CELL_RENDERER_SORTED;
4876           else
4877             flags &= ~GTK_CELL_RENDERER_SORTED;
4878
4879           if (tree_view->priv->cursor_node == node)
4880             flags |= GTK_CELL_RENDERER_FOCUSED;
4881           else
4882             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4883
4884           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
4885             flags |= GTK_CELL_RENDERER_EXPANDABLE;
4886           else
4887             flags &= ~GTK_CELL_RENDERER_EXPANDABLE;
4888
4889           if (node->children)
4890             flags |= GTK_CELL_RENDERER_EXPANDED;
4891           else
4892             flags &= ~GTK_CELL_RENDERER_EXPANDED;
4893
4894           background_area.x = cell_offset;
4895           background_area.width = width;
4896
4897           cell_area = background_area;
4898           cell_area.y += vertical_separator / 2;
4899           cell_area.x += horizontal_separator / 2;
4900           cell_area.height -= vertical_separator;
4901           cell_area.width -= horizontal_separator;
4902
4903           if (draw_vgrid_lines)
4904             {
4905               if (list == first_column)
4906                 {
4907                   cell_area.width -= grid_line_width / 2;
4908                 }
4909               else if (list == last_column)
4910                 {
4911                   cell_area.x += grid_line_width / 2;
4912                   cell_area.width -= grid_line_width / 2;
4913                 }
4914               else
4915                 {
4916                   cell_area.x += grid_line_width / 2;
4917                   cell_area.width -= grid_line_width;
4918                 }
4919             }
4920
4921           if (draw_hgrid_lines)
4922             {
4923               cell_area.y += grid_line_width / 2;
4924               cell_area.height -= grid_line_width;
4925             }
4926
4927           if (!gdk_rectangle_intersect (&clip, &background_area, NULL))
4928             {
4929               cell_offset += gtk_tree_view_column_get_width (column);
4930               continue;
4931             }
4932
4933           gtk_tree_view_column_cell_set_cell_data (column,
4934                                                    tree_view->priv->model,
4935                                                    &iter,
4936                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4937                                                    node->children?TRUE:FALSE);
4938
4939           /* Select the detail for drawing the cell.  relevant
4940            * factors are parity, sortedness, and whether to
4941            * display rules.
4942            */
4943           if (allow_rules && tree_view->priv->has_rules)
4944             {
4945               if (parity)
4946                 row_flags |= GTK_REGION_ODD;
4947               else
4948                 row_flags |= GTK_REGION_EVEN;
4949             }
4950
4951           if ((flags & GTK_CELL_RENDERER_SORTED) &&
4952               n_visible_columns >= 3)
4953             column_flags |= GTK_REGION_SORTED;
4954
4955           is_first = (rtl ? !list->next : !list->prev);
4956           is_last = (rtl ? !list->prev : !list->next);
4957
4958           if (is_first)
4959             column_flags |= GTK_REGION_FIRST;
4960
4961           if (is_last)
4962             column_flags |= GTK_REGION_LAST;
4963
4964           if ((n_col % 2) == 0)
4965             column_flags |= GTK_REGION_EVEN;
4966           else
4967             column_flags |= GTK_REGION_ODD;
4968
4969           gtk_style_context_save (context);
4970
4971           state = gtk_cell_renderer_get_state (NULL, widget, flags);
4972           gtk_style_context_set_state (context, state);
4973
4974           gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4975           gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
4976           gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, column_flags);
4977
4978           if (node == tree_view->priv->cursor_node && has_can_focus_cell
4979               && ((column == tree_view->priv->focus_column
4980                    && tree_view->priv->draw_keyfocus &&
4981                    gtk_widget_has_visible_focus (widget))
4982                   || (column == tree_view->priv->edited_column)))
4983             draw_focus = TRUE;
4984           else
4985             draw_focus = FALSE;
4986
4987           /* Draw background */
4988           gtk_render_background (context, cr,
4989                                  background_area.x,
4990                                  background_area.y,
4991                                  background_area.width,
4992                                  background_area.height);
4993
4994           /* Draw frame */
4995           gtk_render_frame (context, cr,
4996                             background_area.x,
4997                             background_area.y,
4998                             background_area.width,
4999                             background_area.height);
5000
5001           if (gtk_tree_view_is_expander_column (tree_view, column))
5002             {
5003               if (!rtl)
5004                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
5005               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
5006
5007               if (gtk_tree_view_draw_expanders (tree_view))
5008                 {
5009                   if (!rtl)
5010                     cell_area.x += depth * tree_view->priv->expander_size;
5011                   cell_area.width -= depth * tree_view->priv->expander_size;
5012                 }
5013
5014               /* If we have an expander column, the highlight underline
5015                * starts with that column, so that it indicates which
5016                * level of the tree we're dropping at.
5017                */
5018               highlight_x = cell_area.x;
5019               expander_cell_width = cell_area.width;
5020
5021               if (is_separator)
5022                 {
5023                   gtk_style_context_save (context);
5024                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5025
5026                   gtk_render_line (context, cr,
5027                                    cell_area.x,
5028                                    cell_area.y + cell_area.height / 2,
5029                                    cell_area.x + cell_area.width,
5030                                    cell_area.y + cell_area.height / 2);
5031
5032                   gtk_style_context_restore (context);
5033                 }
5034               else
5035                 {
5036                   _gtk_tree_view_column_cell_render (column,
5037                                                      cr,
5038                                                      &background_area,
5039                                                      &cell_area,
5040                                                      flags,
5041                                                      draw_focus);
5042                 }
5043
5044               if (gtk_tree_view_draw_expanders (tree_view)
5045                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
5046                 {
5047                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
5048                                             cr,
5049                                             tree,
5050                                             node);
5051                 }
5052             }
5053           else
5054             {
5055               if (is_separator)
5056                 {
5057                   gtk_style_context_save (context);
5058                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5059
5060                   gtk_render_line (context, cr,
5061                                    cell_area.x,
5062                                    cell_area.y + cell_area.height / 2,
5063                                    cell_area.x + cell_area.width,
5064                                    cell_area.y + cell_area.height / 2);
5065
5066                   gtk_style_context_restore (context);
5067                 }
5068               else
5069                 _gtk_tree_view_column_cell_render (column,
5070                                                    cr,
5071                                                    &background_area,
5072                                                    &cell_area,
5073                                                    flags,
5074                                                    draw_focus);
5075             }
5076
5077           if (draw_hgrid_lines)
5078             {
5079               if (background_area.y > 0)
5080                 gtk_tree_view_draw_line (tree_view, cr,
5081                                          GTK_TREE_VIEW_GRID_LINE,
5082                                          background_area.x, background_area.y,
5083                                          background_area.x + background_area.width,
5084                                          background_area.y);
5085
5086               if (y_offset + max_height >= clip.height)
5087                 gtk_tree_view_draw_line (tree_view, cr,
5088                                          GTK_TREE_VIEW_GRID_LINE,
5089                                          background_area.x, background_area.y + max_height,
5090                                          background_area.x + background_area.width,
5091                                          background_area.y + max_height);
5092             }
5093
5094           if (gtk_tree_view_is_expander_column (tree_view, column) &&
5095               tree_view->priv->tree_lines_enabled)
5096             {
5097               gint x = background_area.x;
5098               gint mult = rtl ? -1 : 1;
5099               gint y0 = background_area.y;
5100               gint y1 = background_area.y + background_area.height/2;
5101               gint y2 = background_area.y + background_area.height;
5102
5103               if (rtl)
5104                 x += background_area.width - 1;
5105
5106               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
5107                   && depth > 1)
5108                 {
5109                   gtk_tree_view_draw_line (tree_view, cr,
5110                                            GTK_TREE_VIEW_TREE_LINE,
5111                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5112                                            y1,
5113                                            x + tree_view->priv->expander_size * (depth - 1.1) * mult,
5114                                            y1);
5115                 }
5116               else if (depth > 1)
5117                 {
5118                   gtk_tree_view_draw_line (tree_view, cr,
5119                                            GTK_TREE_VIEW_TREE_LINE,
5120                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5121                                            y1,
5122                                            x + tree_view->priv->expander_size * (depth - 0.5) * mult,
5123                                            y1);
5124                 }
5125
5126               if (depth > 1)
5127                 {
5128                   gint i;
5129                   GtkRBNode *tmp_node;
5130                   GtkRBTree *tmp_tree;
5131
5132                   if (!_gtk_rbtree_next (tree, node))
5133                     gtk_tree_view_draw_line (tree_view, cr,
5134                                              GTK_TREE_VIEW_TREE_LINE,
5135                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5136                                              y0,
5137                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5138                                              y1);
5139                   else
5140                     gtk_tree_view_draw_line (tree_view, cr,
5141                                              GTK_TREE_VIEW_TREE_LINE,
5142                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5143                                              y0,
5144                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
5145                                              y2);
5146
5147                   tmp_node = tree->parent_node;
5148                   tmp_tree = tree->parent_tree;
5149
5150                   for (i = depth - 2; i > 0; i--)
5151                     {
5152                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
5153                         gtk_tree_view_draw_line (tree_view, cr,
5154                                                  GTK_TREE_VIEW_TREE_LINE,
5155                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
5156                                                  y0,
5157                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
5158                                                  y2);
5159
5160                       tmp_node = tmp_tree->parent_node;
5161                       tmp_tree = tmp_tree->parent_tree;
5162                     }
5163                 }
5164             }
5165
5166           gtk_style_context_restore (context);
5167           cell_offset += gtk_tree_view_column_get_width (column);
5168         }
5169
5170       if (node == drag_highlight)
5171         {
5172           /* Draw indicator for the drop
5173            */
5174           gint highlight_y = -1;
5175           GtkRBTree *tree = NULL;
5176           GtkRBNode *node = NULL;
5177
5178           gtk_style_context_save (context);
5179           gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND);
5180
5181           switch (tree_view->priv->drag_dest_pos)
5182             {
5183             case GTK_TREE_VIEW_DROP_BEFORE:
5184               highlight_y = background_area.y - 1;
5185               if (highlight_y < 0)
5186                       highlight_y = 0;
5187               break;
5188
5189             case GTK_TREE_VIEW_DROP_AFTER:
5190               highlight_y = background_area.y + background_area.height - 1;
5191               break;
5192
5193             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
5194             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
5195               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
5196
5197               if (tree == NULL)
5198                 break;
5199
5200               gtk_render_frame (context, cr,
5201                                 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node),
5202                                 gdk_window_get_width (tree_view->priv->bin_window),
5203                                 gtk_tree_view_get_row_height (tree_view, node));
5204               break;
5205             }
5206
5207           if (highlight_y >= 0)
5208             {
5209               gtk_tree_view_draw_line (tree_view, cr,
5210                                        GTK_TREE_VIEW_FOREGROUND_LINE,
5211                                        rtl ? highlight_x + expander_cell_width : highlight_x,
5212                                        highlight_y,
5213                                        rtl ? 0 : bin_window_width,
5214                                        highlight_y);
5215             }
5216
5217           gtk_style_context_restore (context);
5218         }
5219
5220       /* draw the big row-spanning focus rectangle, if needed */
5221       if (!has_can_focus_cell && node == tree_view->priv->cursor_node &&
5222           tree_view->priv->draw_keyfocus &&
5223           gtk_widget_has_visible_focus (widget))
5224         {
5225           gint tmp_y, tmp_height;
5226           GtkStateFlags focus_rect_state = 0;
5227
5228           gtk_style_context_save (context);
5229
5230           focus_rect_state = gtk_cell_renderer_get_state (NULL, widget, flags);
5231           gtk_style_context_set_state (context, focus_rect_state);
5232
5233           if (draw_hgrid_lines)
5234             {
5235               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node) + grid_line_width / 2;
5236               tmp_height = gtk_tree_view_get_row_height (tree_view, node) - grid_line_width;
5237             }
5238           else
5239             {
5240               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
5241               tmp_height = gtk_tree_view_get_row_height (tree_view, node);
5242             }
5243
5244           gtk_render_focus (context, cr,
5245                             0, tmp_y,
5246                             gdk_window_get_width (tree_view->priv->bin_window),
5247                             tmp_height);
5248
5249           gtk_style_context_restore (context);
5250         }
5251
5252       y_offset += max_height;
5253       if (node->children)
5254         {
5255           GtkTreeIter parent = iter;
5256           gboolean has_child;
5257
5258           tree = node->children;
5259           node = _gtk_rbtree_first (tree);
5260
5261           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
5262                                                     &iter,
5263                                                     &parent);
5264           depth++;
5265
5266           /* Sanity Check! */
5267           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
5268         }
5269       else
5270         {
5271           gboolean done = FALSE;
5272
5273           do
5274             {
5275               node = _gtk_rbtree_next (tree, node);
5276               if (node != NULL)
5277                 {
5278                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
5279                   done = TRUE;
5280
5281                   /* Sanity Check! */
5282                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
5283                 }
5284               else
5285                 {
5286                   GtkTreeIter parent_iter = iter;
5287                   gboolean has_parent;
5288
5289                   node = tree->parent_node;
5290                   tree = tree->parent_tree;
5291                   if (tree == NULL)
5292                     /* we should go to done to free some memory */
5293                     goto done;
5294                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
5295                                                            &iter,
5296                                                            &parent_iter);
5297                   depth--;
5298
5299                   /* Sanity check */
5300                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
5301                 }
5302             }
5303           while (!done);
5304         }
5305     }
5306   while (y_offset < clip.height);
5307
5308 done:
5309   gtk_tree_view_draw_grid_lines (tree_view, cr, n_visible_columns);
5310
5311   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
5312     gtk_tree_view_paint_rubber_band (tree_view, cr);
5313
5314   if (drag_dest_path)
5315     gtk_tree_path_free (drag_dest_path);
5316
5317   return FALSE;
5318 }
5319
5320 static gboolean
5321 gtk_tree_view_draw (GtkWidget *widget,
5322                     cairo_t   *cr)
5323 {
5324   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5325   GtkWidget   *button;
5326
5327   if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
5328     {
5329       GtkStyleContext *context;
5330       GList *tmp_list;
5331
5332       context = gtk_widget_get_style_context (widget);
5333
5334       cairo_save (cr);
5335
5336       gtk_style_context_save (context);
5337       gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
5338
5339       gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
5340
5341       gtk_tree_view_bin_draw (widget, cr);
5342
5343       gtk_style_context_restore (context);
5344       cairo_restore (cr);
5345
5346       /* We can't just chain up to Container::draw as it will try to send the
5347        * event to the headers, so we handle propagating it to our children
5348        * (eg. widgets being edited) ourselves.
5349        */
5350       tmp_list = tree_view->priv->children;
5351       while (tmp_list)
5352         {
5353           GtkTreeViewChild *child = tmp_list->data;
5354           tmp_list = tmp_list->next;
5355
5356           gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
5357         }
5358     }
5359
5360   if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
5361     {
5362       GList *list;
5363
5364       for (list = tree_view->priv->columns; list != NULL; list = list->next)
5365         {
5366           GtkTreeViewColumn *column = list->data;
5367
5368           if (column == tree_view->priv->drag_column)
5369             continue;
5370
5371           if (gtk_tree_view_column_get_visible (column))
5372             {
5373               button = gtk_tree_view_column_get_button (column);
5374               gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5375                                             button, cr);
5376             }
5377         }
5378     }
5379
5380   if (tree_view->priv->drag_window &&
5381       gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
5382     {
5383       button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
5384       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5385                                     button, cr);
5386     }
5387
5388   return FALSE;
5389 }
5390
5391 enum
5392 {
5393   DROP_HOME,
5394   DROP_RIGHT,
5395   DROP_LEFT,
5396   DROP_END
5397 };
5398
5399 /* returns 0x1 when no column has been found -- yes it's hackish */
5400 static GtkTreeViewColumn *
5401 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5402                                GtkTreeViewColumn *column,
5403                                gint               drop_position)
5404 {
5405   GtkTreeViewColumn *left_column = NULL;
5406   GtkTreeViewColumn *cur_column = NULL;
5407   GList *tmp_list;
5408
5409   if (!gtk_tree_view_column_get_reorderable (column))
5410     return (GtkTreeViewColumn *)0x1;
5411
5412   switch (drop_position)
5413     {
5414       case DROP_HOME:
5415         /* find first column where we can drop */
5416         tmp_list = tree_view->priv->columns;
5417         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5418           return (GtkTreeViewColumn *)0x1;
5419
5420         while (tmp_list)
5421           {
5422             g_assert (tmp_list);
5423
5424             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5425             tmp_list = tmp_list->next;
5426
5427             if (left_column &&
5428                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5429               continue;
5430
5431             if (!tree_view->priv->column_drop_func)
5432               return left_column;
5433
5434             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5435               {
5436                 left_column = cur_column;
5437                 continue;
5438               }
5439
5440             return left_column;
5441           }
5442
5443         if (!tree_view->priv->column_drop_func)
5444           return left_column;
5445
5446         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5447           return left_column;
5448         else
5449           return (GtkTreeViewColumn *)0x1;
5450         break;
5451
5452       case DROP_RIGHT:
5453         /* find first column after column where we can drop */
5454         tmp_list = tree_view->priv->columns;
5455
5456         for (; tmp_list; tmp_list = tmp_list->next)
5457           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5458             break;
5459
5460         if (!tmp_list || !tmp_list->next)
5461           return (GtkTreeViewColumn *)0x1;
5462
5463         tmp_list = tmp_list->next;
5464         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5465         tmp_list = tmp_list->next;
5466
5467         while (tmp_list)
5468           {
5469             g_assert (tmp_list);
5470
5471             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5472             tmp_list = tmp_list->next;
5473
5474             if (left_column &&
5475                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5476               {
5477                 left_column = cur_column;
5478                 if (tmp_list)
5479                   tmp_list = tmp_list->next;
5480                 continue;
5481               }
5482
5483             if (!tree_view->priv->column_drop_func)
5484               return left_column;
5485
5486             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5487               {
5488                 left_column = cur_column;
5489                 continue;
5490               }
5491
5492             return left_column;
5493           }
5494
5495         if (!tree_view->priv->column_drop_func)
5496           return left_column;
5497
5498         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5499           return left_column;
5500         else
5501           return (GtkTreeViewColumn *)0x1;
5502         break;
5503
5504       case DROP_LEFT:
5505         /* find first column before column where we can drop */
5506         tmp_list = tree_view->priv->columns;
5507
5508         for (; tmp_list; tmp_list = tmp_list->next)
5509           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5510             break;
5511
5512         if (!tmp_list || !tmp_list->prev)
5513           return (GtkTreeViewColumn *)0x1;
5514
5515         tmp_list = tmp_list->prev;
5516         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5517         tmp_list = tmp_list->prev;
5518
5519         while (tmp_list)
5520           {
5521             g_assert (tmp_list);
5522
5523             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5524
5525             if (left_column &&
5526                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5527               {
5528                 /*if (!tmp_list->prev)
5529                   return (GtkTreeViewColumn *)0x1;
5530                   */
5531 /*
5532                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5533                 tmp_list = tmp_list->prev->prev;
5534                 continue;*/
5535
5536                 cur_column = left_column;
5537                 if (tmp_list)
5538                   tmp_list = tmp_list->prev;
5539                 continue;
5540               }
5541
5542             if (!tree_view->priv->column_drop_func)
5543               return left_column;
5544
5545             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5546               return left_column;
5547
5548             cur_column = left_column;
5549             tmp_list = tmp_list->prev;
5550           }
5551
5552         if (!tree_view->priv->column_drop_func)
5553           return NULL;
5554
5555         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5556           return NULL;
5557         else
5558           return (GtkTreeViewColumn *)0x1;
5559         break;
5560
5561       case DROP_END:
5562         /* same as DROP_HOME case, but doing it backwards */
5563         tmp_list = g_list_last (tree_view->priv->columns);
5564         cur_column = NULL;
5565
5566         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5567           return (GtkTreeViewColumn *)0x1;
5568
5569         while (tmp_list)
5570           {
5571             g_assert (tmp_list);
5572
5573             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5574
5575             if (left_column &&
5576                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5577               {
5578                 cur_column = left_column;
5579                 tmp_list = tmp_list->prev;
5580               }
5581
5582             if (!tree_view->priv->column_drop_func)
5583               return left_column;
5584
5585             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5586               return left_column;
5587
5588             cur_column = left_column;
5589             tmp_list = tmp_list->prev;
5590           }
5591
5592         if (!tree_view->priv->column_drop_func)
5593           return NULL;
5594
5595         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5596           return NULL;
5597         else
5598           return (GtkTreeViewColumn *)0x1;
5599         break;
5600     }
5601
5602   return (GtkTreeViewColumn *)0x1;
5603 }
5604
5605 static gboolean
5606 gtk_tree_view_key_press (GtkWidget   *widget,
5607                          GdkEventKey *event)
5608 {
5609   GtkTreeView *tree_view = (GtkTreeView *) widget;
5610   GtkWidget   *button;
5611
5612   if (tree_view->priv->rubber_band_status)
5613     {
5614       if (event->keyval == GDK_KEY_Escape)
5615         gtk_tree_view_stop_rubber_band (tree_view);
5616
5617       return TRUE;
5618     }
5619
5620   if (tree_view->priv->in_column_drag)
5621     {
5622       if (event->keyval == GDK_KEY_Escape)
5623         {
5624           tree_view->priv->cur_reorder = NULL;
5625           gtk_tree_view_button_release_drag_column (widget, NULL);
5626         }
5627       return TRUE;
5628     }
5629
5630   if (tree_view->priv->headers_visible)
5631     {
5632       GList *focus_column;
5633       gboolean rtl;
5634
5635       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5636
5637       for (focus_column = tree_view->priv->columns;
5638            focus_column;
5639            focus_column = focus_column->next)
5640         {
5641           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5642
5643           button = gtk_tree_view_column_get_button (column);
5644           if (gtk_widget_has_focus (button))
5645             break;
5646         }
5647
5648       if (focus_column &&
5649           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5650           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5651            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right))
5652         {
5653           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5654           gint max_width, min_width;
5655
5656           if (!gtk_tree_view_column_get_resizable (column))
5657             {
5658               gtk_widget_error_bell (widget);
5659               return TRUE;
5660             }
5661
5662           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5663               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5664             {
5665               GtkRequisition button_req;
5666               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5667               gint new_width;
5668
5669               button = gtk_tree_view_column_get_button (column);
5670
5671               gtk_widget_get_preferred_size (button, &button_req, NULL);
5672
5673               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5674               new_width -= 2;
5675               if (new_width < 0)
5676                 new_width = 0;
5677
5678               _gtk_tree_view_column_set_resized_width (column, new_width);
5679
5680               min_width = gtk_tree_view_column_get_min_width (column);
5681               if (min_width == -1)
5682                 new_width = MAX (button_req.width, new_width);
5683               else
5684                 {
5685                   new_width = MAX (min_width, new_width);
5686                 }
5687
5688               max_width = gtk_tree_view_column_get_max_width (column);
5689               if (max_width != -1)
5690                 new_width = MIN (new_width, max_width);
5691
5692               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5693
5694               if (new_width != old_width)
5695                 {
5696                   _gtk_tree_view_column_set_resized_width (column, new_width);
5697                   gtk_widget_queue_resize (widget);
5698                 }
5699               else
5700                 gtk_widget_error_bell (widget);
5701             }
5702           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5703                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5704             {
5705               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5706               gint new_width;
5707
5708               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5709               new_width += 2;
5710
5711               max_width = gtk_tree_view_column_get_max_width (column);
5712               if (max_width != -1)
5713                 new_width = MIN (new_width, max_width);
5714
5715               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5716
5717               if (new_width != old_width)
5718                 {
5719                   _gtk_tree_view_column_set_resized_width (column, new_width);
5720                   gtk_widget_queue_resize (widget);
5721                 }
5722               else
5723                 gtk_widget_error_bell (widget);
5724             }
5725
5726           return TRUE;
5727         }
5728
5729       if (focus_column &&
5730           (event->state & GDK_MOD1_MASK) &&
5731           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5732            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right
5733            || event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home
5734            || event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End))
5735         {
5736           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5737
5738           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5739               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5740             {
5741               GtkTreeViewColumn *col;
5742               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5743               if (col != (GtkTreeViewColumn *)0x1)
5744                 gtk_tree_view_move_column_after (tree_view, column, col);
5745               else
5746                 gtk_widget_error_bell (widget);
5747             }
5748           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5749                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5750             {
5751               GtkTreeViewColumn *col;
5752               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5753               if (col != (GtkTreeViewColumn *)0x1)
5754                 gtk_tree_view_move_column_after (tree_view, column, col);
5755               else
5756                 gtk_widget_error_bell (widget);
5757             }
5758           else if (event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home)
5759             {
5760               GtkTreeViewColumn *col;
5761               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5762               if (col != (GtkTreeViewColumn *)0x1)
5763                 gtk_tree_view_move_column_after (tree_view, column, col);
5764               else
5765                 gtk_widget_error_bell (widget);
5766             }
5767           else if (event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
5768             {
5769               GtkTreeViewColumn *col;
5770               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
5771               if (col != (GtkTreeViewColumn *)0x1)
5772                 gtk_tree_view_move_column_after (tree_view, column, col);
5773               else
5774                 gtk_widget_error_bell (widget);
5775             }
5776
5777           return TRUE;
5778         }
5779     }
5780
5781   /* Chain up to the parent class.  It handles the keybindings. */
5782   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5783     return TRUE;
5784
5785   if (tree_view->priv->search_entry_avoid_unhandled_binding)
5786     {
5787       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
5788       return FALSE;
5789     }
5790
5791   /* We pass the event to the search_entry.  If its text changes, then we start
5792    * the typeahead find capabilities. */
5793   if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
5794       && tree_view->priv->enable_search
5795       && !tree_view->priv->search_custom_entry_set)
5796     {
5797       GdkEvent *new_event;
5798       char *old_text;
5799       const char *new_text;
5800       gboolean retval;
5801       GdkScreen *screen;
5802       gboolean text_modified;
5803       gulong popup_menu_id;
5804
5805       gtk_tree_view_ensure_interactive_directory (tree_view);
5806
5807       /* Make a copy of the current text */
5808       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5809       new_event = gdk_event_copy ((GdkEvent *) event);
5810       g_object_unref (((GdkEventKey *) new_event)->window);
5811       ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
5812       gtk_widget_realize (tree_view->priv->search_window);
5813
5814       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5815                                         "popup-menu", G_CALLBACK (gtk_true),
5816                                         NULL);
5817
5818       /* Move the entry off screen */
5819       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5820       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5821                        gdk_screen_get_width (screen) + 1,
5822                        gdk_screen_get_height (screen) + 1);
5823       gtk_widget_show (tree_view->priv->search_window);
5824
5825       /* Send the event to the window.  If the preedit_changed signal is emitted
5826        * during this event, we will set priv->imcontext_changed  */
5827       tree_view->priv->imcontext_changed = FALSE;
5828       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5829       gdk_event_free (new_event);
5830       gtk_widget_hide (tree_view->priv->search_window);
5831
5832       g_signal_handler_disconnect (tree_view->priv->search_entry,
5833                                    popup_menu_id);
5834
5835       /* We check to make sure that the entry tried to handle the text, and that
5836        * the text has changed.
5837        */
5838       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5839       text_modified = strcmp (old_text, new_text) != 0;
5840       g_free (old_text);
5841       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5842           (retval && text_modified))               /* ...or the text was modified */
5843         {
5844           if (gtk_tree_view_real_start_interactive_search (tree_view,
5845                                                            gdk_event_get_device ((GdkEvent *) event),
5846                                                            FALSE))
5847             {
5848               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5849               return TRUE;
5850             }
5851           else
5852             {
5853               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5854               return FALSE;
5855             }
5856         }
5857     }
5858
5859   return FALSE;
5860 }
5861
5862 static gboolean
5863 gtk_tree_view_key_release (GtkWidget   *widget,
5864                            GdkEventKey *event)
5865 {
5866   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5867
5868   if (tree_view->priv->rubber_band_status)
5869     return TRUE;
5870
5871   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5872 }
5873
5874 /* FIXME Is this function necessary? Can I get an enter_notify event
5875  * w/o either an expose event or a mouse motion event?
5876  */
5877 static gboolean
5878 gtk_tree_view_enter_notify (GtkWidget        *widget,
5879                             GdkEventCrossing *event)
5880 {
5881   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5882   GtkRBTree *tree;
5883   GtkRBNode *node;
5884   gint new_y;
5885
5886   /* Sanity check it */
5887   if (event->window != tree_view->priv->bin_window)
5888     return FALSE;
5889
5890   if (tree_view->priv->tree == NULL)
5891     return FALSE;
5892
5893   if (event->mode == GDK_CROSSING_GRAB ||
5894       event->mode == GDK_CROSSING_GTK_GRAB ||
5895       event->mode == GDK_CROSSING_GTK_UNGRAB ||
5896       event->mode == GDK_CROSSING_STATE_CHANGED)
5897     return TRUE;
5898
5899   /* find the node internally */
5900   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5901   if (new_y < 0)
5902     new_y = 0;
5903   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5904
5905   tree_view->priv->event_last_x = event->x;
5906   tree_view->priv->event_last_y = event->y;
5907
5908   if ((tree_view->priv->button_pressed_node == NULL) ||
5909       (tree_view->priv->button_pressed_node == node))
5910     prelight_or_select (tree_view, tree, node, event->x, event->y);
5911
5912   return TRUE;
5913 }
5914
5915 static gboolean
5916 gtk_tree_view_leave_notify (GtkWidget        *widget,
5917                             GdkEventCrossing *event)
5918 {
5919   GtkTreeView *tree_view;
5920
5921   if (event->mode == GDK_CROSSING_GRAB ||
5922       event->mode == GDK_CROSSING_GTK_GRAB ||
5923       event->mode == GDK_CROSSING_GTK_UNGRAB)
5924     return TRUE;
5925
5926   tree_view = GTK_TREE_VIEW (widget);
5927
5928   if (tree_view->priv->prelight_node)
5929     _gtk_tree_view_queue_draw_node (tree_view,
5930                                    tree_view->priv->prelight_tree,
5931                                    tree_view->priv->prelight_node,
5932                                    NULL);
5933
5934   tree_view->priv->event_last_x = -10000;
5935   tree_view->priv->event_last_y = -10000;
5936
5937   prelight_or_select (tree_view,
5938                       NULL, NULL,
5939                       -1000, -1000); /* coords not possibly over an arrow */
5940
5941   return TRUE;
5942 }
5943
5944
5945 static gint
5946 gtk_tree_view_focus_out (GtkWidget     *widget,
5947                          GdkEventFocus *event)
5948 {
5949   GtkTreeView *tree_view;
5950
5951   tree_view = GTK_TREE_VIEW (widget);
5952
5953   gtk_widget_queue_draw (widget);
5954
5955   /* destroy interactive search dialog */
5956   if (tree_view->priv->search_window)
5957     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
5958                                       gdk_event_get_device ((GdkEvent *) event));
5959
5960   return FALSE;
5961 }
5962
5963
5964 /* Incremental Reflow
5965  */
5966
5967 static void
5968 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
5969                                  GtkRBTree   *tree,
5970                                  GtkRBNode   *node)
5971 {
5972   GtkAllocation allocation;
5973   gint y;
5974
5975   y = _gtk_rbtree_node_find_offset (tree, node)
5976     - gtk_adjustment_get_value (tree_view->priv->vadjustment)
5977     + gtk_tree_view_get_effective_header_height (tree_view);
5978
5979   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
5980   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
5981                               0, y,
5982                               allocation.width,
5983                               GTK_RBNODE_GET_HEIGHT (node));
5984 }
5985
5986 static gboolean
5987 node_is_visible (GtkTreeView *tree_view,
5988                  GtkRBTree   *tree,
5989                  GtkRBNode   *node)
5990 {
5991   int y;
5992   int height;
5993
5994   y = _gtk_rbtree_node_find_offset (tree, node);
5995   height = gtk_tree_view_get_row_height (tree_view, node);
5996
5997   if (y >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
5998       y + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
5999                      + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6000     return TRUE;
6001
6002   return FALSE;
6003 }
6004
6005 /* Returns TRUE if it updated the size
6006  */
6007 static gboolean
6008 validate_row (GtkTreeView *tree_view,
6009               GtkRBTree   *tree,
6010               GtkRBNode   *node,
6011               GtkTreeIter *iter,
6012               GtkTreePath *path)
6013 {
6014   GtkTreeViewColumn *column;
6015   GList *list, *first_column, *last_column;
6016   gint height = 0;
6017   gint horizontal_separator;
6018   gint vertical_separator;
6019   gint depth = gtk_tree_path_get_depth (path);
6020   gboolean retval = FALSE;
6021   gboolean is_separator = FALSE;
6022   gboolean draw_vgrid_lines, draw_hgrid_lines;
6023   gint focus_pad;
6024   gint grid_line_width;
6025   gboolean wide_separators;
6026   gint separator_height;
6027
6028   /* double check the row needs validating */
6029   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
6030       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6031     return FALSE;
6032
6033   is_separator = row_is_separator (tree_view, iter, NULL);
6034
6035   gtk_widget_style_get (GTK_WIDGET (tree_view),
6036                         "focus-padding", &focus_pad,
6037                         "horizontal-separator", &horizontal_separator,
6038                         "vertical-separator", &vertical_separator,
6039                         "grid-line-width", &grid_line_width,
6040                         "wide-separators",  &wide_separators,
6041                         "separator-height", &separator_height,
6042                         NULL);
6043
6044   draw_vgrid_lines =
6045     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
6046     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6047   draw_hgrid_lines =
6048     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
6049     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6050
6051   for (last_column = g_list_last (tree_view->priv->columns);
6052        last_column &&
6053        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
6054        last_column = last_column->prev)
6055     ;
6056
6057   for (first_column = g_list_first (tree_view->priv->columns);
6058        first_column &&
6059        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
6060        first_column = first_column->next)
6061     ;
6062
6063   for (list = tree_view->priv->columns; list; list = list->next)
6064     {
6065       gint padding = 0;
6066       gint original_width;
6067       gint new_width;
6068       gint row_height;
6069
6070       column = list->data;
6071
6072       if (!gtk_tree_view_column_get_visible (column))
6073         continue;
6074
6075       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) &&
6076           !_gtk_tree_view_column_cell_get_dirty (column))
6077         continue;
6078
6079       original_width = _gtk_tree_view_column_get_requested_width (column);
6080
6081       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
6082                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
6083                                                node->children?TRUE:FALSE);
6084       gtk_tree_view_column_cell_get_size (column,
6085                                           NULL, NULL, NULL,
6086                                           NULL, &row_height);
6087
6088       if (!is_separator)
6089         {
6090           row_height += vertical_separator;
6091           height = MAX (height, row_height);
6092           height = MAX (height, tree_view->priv->expander_size);
6093         }
6094       else
6095         {
6096           if (wide_separators)
6097             height = separator_height + 2 * focus_pad;
6098           else
6099             height = 2 + 2 * focus_pad;
6100         }
6101
6102       if (gtk_tree_view_is_expander_column (tree_view, column))
6103         {
6104           padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
6105
6106           if (gtk_tree_view_draw_expanders (tree_view))
6107             padding += depth * tree_view->priv->expander_size;
6108         }
6109       else
6110         padding += horizontal_separator;
6111
6112       if (draw_vgrid_lines)
6113         {
6114           if (list->data == first_column || list->data == last_column)
6115             padding += grid_line_width / 2.0;
6116           else
6117             padding += grid_line_width;
6118         }
6119
6120       /* Update the padding for the column */
6121       _gtk_tree_view_column_push_padding (column, padding);
6122       new_width = _gtk_tree_view_column_get_requested_width (column);
6123
6124       if (new_width > original_width)
6125         retval = TRUE;
6126     }
6127
6128   if (draw_hgrid_lines)
6129     height += grid_line_width;
6130
6131   if (height != GTK_RBNODE_GET_HEIGHT (node))
6132     {
6133       retval = TRUE;
6134       _gtk_rbtree_node_set_height (tree, node, height);
6135     }
6136   _gtk_rbtree_node_mark_valid (tree, node);
6137   tree_view->priv->post_validation_flag = TRUE;
6138
6139   return retval;
6140 }
6141
6142
6143 static void
6144 validate_visible_area (GtkTreeView *tree_view)
6145 {
6146   GtkAllocation allocation;
6147   GtkTreePath *path = NULL;
6148   GtkTreePath *above_path = NULL;
6149   GtkTreeIter iter;
6150   GtkRBTree *tree = NULL;
6151   GtkRBNode *node = NULL;
6152   gboolean need_redraw = FALSE;
6153   gboolean size_changed = FALSE;
6154   gint total_height;
6155   gint area_above = 0;
6156   gint area_below = 0;
6157
6158   if (tree_view->priv->tree == NULL)
6159     return;
6160
6161   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
6162       tree_view->priv->scroll_to_path == NULL)
6163     return;
6164
6165   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
6166   total_height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
6167
6168   if (total_height == 0)
6169     return;
6170
6171   /* First, we check to see if we need to scroll anywhere
6172    */
6173   if (tree_view->priv->scroll_to_path)
6174     {
6175       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
6176       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
6177         {
6178           /* we are going to scroll, and will update dy */
6179           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6180           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6181               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6182             {
6183               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6184               if (validate_row (tree_view, tree, node, &iter, path))
6185                 size_changed = TRUE;
6186             }
6187
6188           if (tree_view->priv->scroll_to_use_align)
6189             {
6190               gint height = gtk_tree_view_get_row_height (tree_view, node);
6191               area_above = (total_height - height) *
6192                 tree_view->priv->scroll_to_row_align;
6193               area_below = total_height - area_above - height;
6194               area_above = MAX (area_above, 0);
6195               area_below = MAX (area_below, 0);
6196             }
6197           else
6198             {
6199               /* two cases:
6200                * 1) row not visible
6201                * 2) row visible
6202                */
6203               gint dy;
6204               gint height = gtk_tree_view_get_row_height (tree_view, node);
6205
6206               dy = _gtk_rbtree_node_find_offset (tree, node);
6207
6208               if (dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6209                   dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6210                                   + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6211                 {
6212                   /* row visible: keep the row at the same position */
6213                   area_above = dy - gtk_adjustment_get_value (tree_view->priv->vadjustment);
6214                   area_below = (gtk_adjustment_get_value (tree_view->priv->vadjustment) +
6215                                 gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6216                                - dy - height;
6217                 }
6218               else
6219                 {
6220                   /* row not visible */
6221                   if (dy >= 0
6222                       && dy + height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6223                     {
6224                       /* row at the beginning -- fixed */
6225                       area_above = dy;
6226                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment)
6227                                    - area_above - height;
6228                     }
6229                   else if (dy >= (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6230                                   gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6231                     {
6232                       /* row at the end -- fixed */
6233                       area_above = dy - (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6234                                    gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6235                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) -
6236                                    area_above - height;
6237
6238                       if (area_below < 0)
6239                         {
6240                           area_above = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - height;
6241                           area_below = 0;
6242                         }
6243                     }
6244                   else
6245                     {
6246                       /* row somewhere in the middle, bring it to the top
6247                        * of the view
6248                        */
6249                       area_above = 0;
6250                       area_below = total_height - height;
6251                     }
6252                 }
6253             }
6254         }
6255       else
6256         /* the scroll to isn't valid; ignore it.
6257          */
6258         {
6259           if (tree_view->priv->scroll_to_path && !path)
6260             {
6261               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6262               tree_view->priv->scroll_to_path = NULL;
6263             }
6264           if (path)
6265             gtk_tree_path_free (path);
6266           path = NULL;
6267         }
6268     }
6269
6270   /* We didn't have a scroll_to set, so we just handle things normally
6271    */
6272   if (path == NULL)
6273     {
6274       gint offset;
6275
6276       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6277                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
6278                                         &tree, &node);
6279       if (node == NULL)
6280         {
6281           /* In this case, nothing has been validated */
6282           path = gtk_tree_path_new_first ();
6283           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6284         }
6285       else
6286         {
6287           path = _gtk_tree_path_new_from_rbtree (tree, node);
6288           total_height += offset;
6289         }
6290
6291       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6292
6293       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6294           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6295         {
6296           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6297           if (validate_row (tree_view, tree, node, &iter, path))
6298             size_changed = TRUE;
6299         }
6300       area_above = 0;
6301       area_below = total_height - gtk_tree_view_get_row_height (tree_view, node);
6302     }
6303
6304   above_path = gtk_tree_path_copy (path);
6305
6306   /* if we do not validate any row above the new top_row, we will make sure
6307    * that the row immediately above top_row has been validated. (if we do not
6308    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
6309    * when invalidated that row's height will be zero. and this will mess up
6310    * scrolling).
6311    */
6312   if (area_above == 0)
6313     {
6314       GtkRBTree *tmptree;
6315       GtkRBNode *tmpnode;
6316
6317       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
6318       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
6319
6320       if (tmpnode)
6321         {
6322           GtkTreePath *tmppath;
6323           GtkTreeIter tmpiter;
6324
6325           tmppath = _gtk_tree_path_new_from_rbtree (tmptree, tmpnode);
6326           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
6327
6328           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
6329               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
6330             {
6331               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
6332               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
6333                 size_changed = TRUE;
6334             }
6335
6336           gtk_tree_path_free (tmppath);
6337         }
6338     }
6339
6340   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
6341    * backwards is much slower then forward, as there is no iter_prev function.
6342    * We go forwards first in case we run out of tree.  Then we go backwards to
6343    * fill out the top.
6344    */
6345   while (node && area_below > 0)
6346     {
6347       if (node->children)
6348         {
6349           GtkTreeIter parent = iter;
6350           gboolean has_child;
6351
6352           tree = node->children;
6353           node = _gtk_rbtree_first (tree);
6354
6355           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
6356                                                     &iter,
6357                                                     &parent);
6358           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
6359           gtk_tree_path_down (path);
6360         }
6361       else
6362         {
6363           gboolean done = FALSE;
6364           do
6365             {
6366               node = _gtk_rbtree_next (tree, node);
6367               if (node != NULL)
6368                 {
6369                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
6370                   done = TRUE;
6371                   gtk_tree_path_next (path);
6372
6373                   /* Sanity Check! */
6374                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
6375                 }
6376               else
6377                 {
6378                   GtkTreeIter parent_iter = iter;
6379                   gboolean has_parent;
6380
6381                   node = tree->parent_node;
6382                   tree = tree->parent_tree;
6383                   if (tree == NULL)
6384                     break;
6385                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
6386                                                            &iter,
6387                                                            &parent_iter);
6388                   gtk_tree_path_up (path);
6389
6390                   /* Sanity check */
6391                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
6392                 }
6393             }
6394           while (!done);
6395         }
6396
6397       if (!node)
6398         break;
6399
6400       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6401           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6402         {
6403           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6404           if (validate_row (tree_view, tree, node, &iter, path))
6405               size_changed = TRUE;
6406         }
6407
6408       area_below -= gtk_tree_view_get_row_height (tree_view, node);
6409     }
6410   gtk_tree_path_free (path);
6411
6412   /* If we ran out of tree, and have extra area_below left, we need to add it
6413    * to area_above */
6414   if (area_below > 0)
6415     area_above += area_below;
6416
6417   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
6418
6419   /* We walk backwards */
6420   while (area_above > 0)
6421     {
6422       _gtk_rbtree_prev_full (tree, node, &tree, &node);
6423
6424       /* Always find the new path in the tree.  We cannot just assume
6425        * a gtk_tree_path_prev() is enough here, as there might be children
6426        * in between this node and the previous sibling node.  If this
6427        * appears to be a performance hotspot in profiles, we can look into
6428        * intrigate logic for keeping path, node and iter in sync like
6429        * we do for forward walks.  (Which will be hard because of the lacking
6430        * iter_prev).
6431        */
6432
6433       if (node == NULL)
6434         break;
6435
6436       gtk_tree_path_free (above_path);
6437       above_path = _gtk_tree_path_new_from_rbtree (tree, node);
6438
6439       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
6440
6441       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6442           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6443         {
6444           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6445           if (validate_row (tree_view, tree, node, &iter, above_path))
6446             size_changed = TRUE;
6447         }
6448       area_above -= gtk_tree_view_get_row_height (tree_view, node);
6449     }
6450
6451   /* if we scrolled to a path, we need to set the dy here,
6452    * and sync the top row accordingly
6453    */
6454   if (tree_view->priv->scroll_to_path)
6455     {
6456       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6457       gtk_tree_view_top_row_to_dy (tree_view);
6458
6459       need_redraw = TRUE;
6460     }
6461   else if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6462     {
6463       /* when we are not scrolling, we should never set dy to something
6464        * else than zero. we update top_row to be in sync with dy = 0.
6465        */
6466       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6467       gtk_tree_view_dy_to_top_row (tree_view);
6468     }
6469   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6470     {
6471       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6472       gtk_tree_view_dy_to_top_row (tree_view);
6473     }
6474   else
6475     gtk_tree_view_top_row_to_dy (tree_view);
6476
6477   /* update width/height and queue a resize */
6478   if (size_changed)
6479     {
6480       GtkRequisition requisition;
6481
6482       /* We temporarily guess a size, under the assumption that it will be the
6483        * same when we get our next size_allocate.  If we don't do this, we'll be
6484        * in an inconsistent state if we call top_row_to_dy. */
6485
6486       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6487                                      &requisition, NULL);
6488       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6489                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6490       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6491                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6492       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6493     }
6494
6495   if (tree_view->priv->scroll_to_path)
6496     {
6497       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6498       tree_view->priv->scroll_to_path = NULL;
6499     }
6500
6501   if (above_path)
6502     gtk_tree_path_free (above_path);
6503
6504   if (tree_view->priv->scroll_to_column)
6505     {
6506       tree_view->priv->scroll_to_column = NULL;
6507     }
6508   if (need_redraw)
6509     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6510 }
6511
6512 static void
6513 initialize_fixed_height_mode (GtkTreeView *tree_view)
6514 {
6515   if (!tree_view->priv->tree)
6516     return;
6517
6518   if (tree_view->priv->fixed_height < 0)
6519     {
6520       GtkTreeIter iter;
6521       GtkTreePath *path;
6522
6523       GtkRBTree *tree = NULL;
6524       GtkRBNode *node = NULL;
6525
6526       tree = tree_view->priv->tree;
6527       node = tree->root;
6528
6529       path = _gtk_tree_path_new_from_rbtree (tree, node);
6530       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6531
6532       validate_row (tree_view, tree, node, &iter, path);
6533
6534       gtk_tree_path_free (path);
6535
6536       tree_view->priv->fixed_height = gtk_tree_view_get_row_height (tree_view, node);
6537     }
6538
6539    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6540                                  tree_view->priv->fixed_height, TRUE);
6541 }
6542
6543 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6544  * the left-most uninvalidated node.  We then try walking right, validating
6545  * nodes.  Once we find a valid node, we repeat the previous process of finding
6546  * the first invalid node.
6547  */
6548
6549 static gboolean
6550 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6551 {
6552   GtkRBTree *tree = NULL;
6553   GtkRBNode *node = NULL;
6554   gboolean validated_area = FALSE;
6555   gint retval = TRUE;
6556   GtkTreePath *path = NULL;
6557   GtkTreeIter iter;
6558   GTimer *timer;
6559   gint i = 0;
6560
6561   gint y = -1;
6562   gint prev_height = -1;
6563   gboolean fixed_height = TRUE;
6564
6565   g_assert (tree_view);
6566
6567   if (tree_view->priv->tree == NULL)
6568       return FALSE;
6569
6570   if (tree_view->priv->fixed_height_mode)
6571     {
6572       if (tree_view->priv->fixed_height < 0)
6573         initialize_fixed_height_mode (tree_view);
6574
6575       return FALSE;
6576     }
6577
6578   timer = g_timer_new ();
6579   g_timer_start (timer);
6580
6581   do
6582     {
6583       gboolean changed = FALSE;
6584
6585       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6586         {
6587           retval = FALSE;
6588           goto done;
6589         }
6590
6591       if (path != NULL)
6592         {
6593           node = _gtk_rbtree_next (tree, node);
6594           if (node != NULL)
6595             {
6596               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6597               gtk_tree_path_next (path);
6598             }
6599           else
6600             {
6601               gtk_tree_path_free (path);
6602               path = NULL;
6603             }
6604         }
6605
6606       if (path == NULL)
6607         {
6608           tree = tree_view->priv->tree;
6609           node = tree_view->priv->tree->root;
6610
6611           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6612
6613           do
6614             {
6615               if (!_gtk_rbtree_is_nil (node->left) &&
6616                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6617                 {
6618                   node = node->left;
6619                 }
6620               else if (!_gtk_rbtree_is_nil (node->right) &&
6621                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6622                 {
6623                   node = node->right;
6624                 }
6625               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6626                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6627                 {
6628                   break;
6629                 }
6630               else if (node->children != NULL)
6631                 {
6632                   tree = node->children;
6633                   node = tree->root;
6634                 }
6635               else
6636                 /* RBTree corruption!  All bad */
6637                 g_assert_not_reached ();
6638             }
6639           while (TRUE);
6640           path = _gtk_tree_path_new_from_rbtree (tree, node);
6641           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6642         }
6643
6644       changed = validate_row (tree_view, tree, node, &iter, path);
6645       validated_area = changed || validated_area;
6646
6647       if (changed)
6648         {
6649           gint offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
6650
6651           if (y == -1 || y > offset)
6652             y = offset;
6653         }
6654
6655       if (!tree_view->priv->fixed_height_check)
6656         {
6657           gint height;
6658
6659           height = gtk_tree_view_get_row_height (tree_view, node);
6660           if (prev_height < 0)
6661             prev_height = height;
6662           else if (prev_height != height)
6663             fixed_height = FALSE;
6664         }
6665
6666       i++;
6667     }
6668   while (g_timer_elapsed (timer, NULL) < GTK_TREE_VIEW_TIME_MS_PER_IDLE / 1000.);
6669
6670   if (!tree_view->priv->fixed_height_check)
6671    {
6672      if (fixed_height)
6673        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6674
6675      tree_view->priv->fixed_height_check = 1;
6676    }
6677
6678  done:
6679   if (validated_area)
6680     {
6681       GtkRequisition requisition;
6682
6683       /* We temporarily guess a size, under the assumption that it will be the
6684        * same when we get our next size_allocate.  If we don't do this, we'll be
6685        * in an inconsistent state when we call top_row_to_dy. */
6686
6687       /* FIXME: This is called from size_request, for some reason it is not infinitely
6688        * recursing, we cannot call gtk_widget_get_preferred_size() here because that's
6689        * not allowed (from inside ->get_preferred_width/height() implementations, one
6690        * should call the vfuncs directly). However what is desired here is the full
6691        * size including any margins and limited by any alignment (i.e. after
6692        * GtkWidget:adjust_size_request() is called).
6693        *
6694        * Currently bypassing this but the real solution is to not update the scroll adjustments
6695        * untill we've recieved an allocation (never update scroll adjustments from size-requests).
6696        */
6697       gtk_tree_view_size_request (GTK_WIDGET (tree_view), &requisition, FALSE);
6698
6699       /* If rows above the current position have changed height, this has
6700        * affected the current view and thus needs a redraw.
6701        */
6702       if (y != -1 && y < gtk_adjustment_get_value (tree_view->priv->vadjustment))
6703         gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6704
6705       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6706                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6707       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6708                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6709
6710       if (queue_resize)
6711         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
6712     }
6713
6714   if (path) gtk_tree_path_free (path);
6715   g_timer_destroy (timer);
6716
6717   return retval;
6718 }
6719
6720 static gboolean
6721 validate_rows (GtkTreeView *tree_view)
6722 {
6723   gboolean retval;
6724
6725   retval = do_validate_rows (tree_view, TRUE);
6726
6727   if (! retval && tree_view->priv->validate_rows_timer)
6728     {
6729       g_source_remove (tree_view->priv->validate_rows_timer);
6730       tree_view->priv->validate_rows_timer = 0;
6731     }
6732
6733   return retval;
6734 }
6735
6736 static gboolean
6737 validate_rows_handler (GtkTreeView *tree_view)
6738 {
6739   gboolean retval;
6740
6741   retval = do_validate_rows (tree_view, TRUE);
6742   if (! retval && tree_view->priv->validate_rows_timer)
6743     {
6744       g_source_remove (tree_view->priv->validate_rows_timer);
6745       tree_view->priv->validate_rows_timer = 0;
6746     }
6747
6748   return retval;
6749 }
6750
6751 static gboolean
6752 do_presize_handler (GtkTreeView *tree_view)
6753 {
6754   if (tree_view->priv->mark_rows_col_dirty)
6755     {
6756       if (tree_view->priv->tree)
6757         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6758       tree_view->priv->mark_rows_col_dirty = FALSE;
6759     }
6760   validate_visible_area (tree_view);
6761   tree_view->priv->presize_handler_timer = 0;
6762
6763   if (tree_view->priv->fixed_height_mode)
6764     {
6765       GtkRequisition requisition;
6766
6767       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6768                                      &requisition, NULL);
6769
6770       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6771                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6772       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6773                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6774       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6775     }
6776
6777   return FALSE;
6778 }
6779
6780 static gboolean
6781 presize_handler_callback (gpointer data)
6782 {
6783   do_presize_handler (GTK_TREE_VIEW (data));
6784
6785   return FALSE;
6786 }
6787
6788 static void
6789 install_presize_handler (GtkTreeView *tree_view)
6790 {
6791   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6792     return;
6793
6794   if (! tree_view->priv->presize_handler_timer)
6795     {
6796       tree_view->priv->presize_handler_timer =
6797         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6798     }
6799   if (! tree_view->priv->validate_rows_timer)
6800     {
6801       tree_view->priv->validate_rows_timer =
6802         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6803     }
6804 }
6805
6806 static void
6807 gtk_tree_view_bin_process_updates (GtkTreeView *tree_view)
6808 {
6809   /* Prior to drawing, we make sure the visible area is validated. */
6810   if (tree_view->priv->presize_handler_timer)
6811     {
6812       g_source_remove (tree_view->priv->presize_handler_timer);
6813       tree_view->priv->presize_handler_timer = 0;
6814
6815       do_presize_handler (tree_view);
6816     }
6817
6818   gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
6819 }
6820
6821 static gboolean
6822 scroll_sync_handler (GtkTreeView *tree_view)
6823 {
6824   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6825     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6826   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6827     gtk_tree_view_top_row_to_dy (tree_view);
6828   else
6829     gtk_tree_view_dy_to_top_row (tree_view);
6830
6831   tree_view->priv->scroll_sync_timer = 0;
6832
6833   return FALSE;
6834 }
6835
6836 static void
6837 install_scroll_sync_handler (GtkTreeView *tree_view)
6838 {
6839   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6840     return;
6841
6842   if (!tree_view->priv->scroll_sync_timer)
6843     {
6844       tree_view->priv->scroll_sync_timer =
6845         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6846     }
6847 }
6848
6849 static void
6850 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6851                            GtkTreePath *path,
6852                            gint         offset)
6853 {
6854   gtk_tree_row_reference_free (tree_view->priv->top_row);
6855
6856   if (!path)
6857     {
6858       tree_view->priv->top_row = NULL;
6859       tree_view->priv->top_row_dy = 0;
6860     }
6861   else
6862     {
6863       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6864       tree_view->priv->top_row_dy = offset;
6865     }
6866 }
6867
6868 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6869  * it's set to be NULL, and top_row_dy is 0;
6870  */
6871 static void
6872 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6873 {
6874   gint offset;
6875   GtkTreePath *path;
6876   GtkRBTree *tree;
6877   GtkRBNode *node;
6878
6879   if (tree_view->priv->tree == NULL)
6880     {
6881       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6882     }
6883   else
6884     {
6885       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6886                                         tree_view->priv->dy,
6887                                         &tree, &node);
6888
6889       if (tree == NULL)
6890         {
6891           gtk_tree_view_set_top_row (tree_view, NULL, 0);
6892         }
6893       else
6894         {
6895           path = _gtk_tree_path_new_from_rbtree (tree, node);
6896           gtk_tree_view_set_top_row (tree_view, path, offset);
6897           gtk_tree_path_free (path);
6898         }
6899     }
6900 }
6901
6902 static void
6903 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6904 {
6905   GtkTreePath *path;
6906   GtkRBTree *tree;
6907   GtkRBNode *node;
6908   int new_dy;
6909
6910   /* Avoid recursive calls */
6911   if (tree_view->priv->in_top_row_to_dy)
6912     return;
6913
6914   if (tree_view->priv->top_row)
6915     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6916   else
6917     path = NULL;
6918
6919   if (!path)
6920     tree = NULL;
6921   else
6922     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6923
6924   if (path)
6925     gtk_tree_path_free (path);
6926
6927   if (tree == NULL)
6928     {
6929       /* keep dy and set new toprow */
6930       gtk_tree_row_reference_free (tree_view->priv->top_row);
6931       tree_view->priv->top_row = NULL;
6932       tree_view->priv->top_row_dy = 0;
6933       /* DO NOT install the idle handler */
6934       gtk_tree_view_dy_to_top_row (tree_view);
6935       return;
6936     }
6937
6938   if (gtk_tree_view_get_row_height (tree_view, node)
6939       < tree_view->priv->top_row_dy)
6940     {
6941       /* new top row -- do NOT install the idle handler */
6942       gtk_tree_view_dy_to_top_row (tree_view);
6943       return;
6944     }
6945
6946   new_dy = _gtk_rbtree_node_find_offset (tree, node);
6947   new_dy += tree_view->priv->top_row_dy;
6948
6949   if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6950     new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
6951
6952   new_dy = MAX (0, new_dy);
6953
6954   tree_view->priv->in_top_row_to_dy = TRUE;
6955   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
6956   tree_view->priv->in_top_row_to_dy = FALSE;
6957 }
6958
6959
6960 void
6961 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view,
6962                                             gboolean     install_handler)
6963 {
6964   tree_view->priv->mark_rows_col_dirty = TRUE;
6965
6966   if (install_handler)
6967     install_presize_handler (tree_view);
6968 }
6969
6970 /*
6971  * This function works synchronously (due to the while (validate_rows...)
6972  * loop).
6973  *
6974  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
6975  * here. You now need to check that yourself.
6976  */
6977 void
6978 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
6979                                 GtkTreeViewColumn *column)
6980 {
6981   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6982   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
6983
6984   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
6985
6986   do_presize_handler (tree_view);
6987   while (validate_rows (tree_view));
6988
6989   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6990 }
6991
6992 /* Drag-and-drop */
6993
6994 static void
6995 set_source_row (GdkDragContext *context,
6996                 GtkTreeModel   *model,
6997                 GtkTreePath    *source_row)
6998 {
6999   g_object_set_data_full (G_OBJECT (context),
7000                           I_("gtk-tree-view-source-row"),
7001                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
7002                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
7003 }
7004
7005 static GtkTreePath*
7006 get_source_row (GdkDragContext *context)
7007 {
7008   GtkTreeRowReference *ref =
7009     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
7010
7011   if (ref)
7012     return gtk_tree_row_reference_get_path (ref);
7013   else
7014     return NULL;
7015 }
7016
7017 typedef struct
7018 {
7019   GtkTreeRowReference *dest_row;
7020   guint                path_down_mode   : 1;
7021   guint                empty_view_drop  : 1;
7022   guint                drop_append_mode : 1;
7023 }
7024 DestRow;
7025
7026 static void
7027 dest_row_free (gpointer data)
7028 {
7029   DestRow *dr = (DestRow *)data;
7030
7031   gtk_tree_row_reference_free (dr->dest_row);
7032   g_slice_free (DestRow, dr);
7033 }
7034
7035 static void
7036 set_dest_row (GdkDragContext *context,
7037               GtkTreeModel   *model,
7038               GtkTreePath    *dest_row,
7039               gboolean        path_down_mode,
7040               gboolean        empty_view_drop,
7041               gboolean        drop_append_mode)
7042 {
7043   DestRow *dr;
7044
7045   if (!dest_row)
7046     {
7047       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7048                               NULL, NULL);
7049       return;
7050     }
7051
7052   dr = g_slice_new (DestRow);
7053
7054   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
7055   dr->path_down_mode = path_down_mode != FALSE;
7056   dr->empty_view_drop = empty_view_drop != FALSE;
7057   dr->drop_append_mode = drop_append_mode != FALSE;
7058
7059   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7060                           dr, (GDestroyNotify) dest_row_free);
7061 }
7062
7063 static GtkTreePath*
7064 get_dest_row (GdkDragContext *context,
7065               gboolean       *path_down_mode)
7066 {
7067   DestRow *dr =
7068     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
7069
7070   if (dr)
7071     {
7072       GtkTreePath *path = NULL;
7073
7074       if (path_down_mode)
7075         *path_down_mode = dr->path_down_mode;
7076
7077       if (dr->dest_row)
7078         path = gtk_tree_row_reference_get_path (dr->dest_row);
7079       else if (dr->empty_view_drop)
7080         path = gtk_tree_path_new_from_indices (0, -1);
7081       else
7082         path = NULL;
7083
7084       if (path && dr->drop_append_mode)
7085         gtk_tree_path_next (path);
7086
7087       return path;
7088     }
7089   else
7090     return NULL;
7091 }
7092
7093 /* Get/set whether drag_motion requested the drag data and
7094  * drag_data_received should thus not actually insert the data,
7095  * since the data doesn't result from a drop.
7096  */
7097 static void
7098 set_status_pending (GdkDragContext *context,
7099                     GdkDragAction   suggested_action)
7100 {
7101   g_object_set_data (G_OBJECT (context),
7102                      I_("gtk-tree-view-status-pending"),
7103                      GINT_TO_POINTER (suggested_action));
7104 }
7105
7106 static GdkDragAction
7107 get_status_pending (GdkDragContext *context)
7108 {
7109   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
7110                                              "gtk-tree-view-status-pending"));
7111 }
7112
7113 static TreeViewDragInfo*
7114 get_info (GtkTreeView *tree_view)
7115 {
7116   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
7117 }
7118
7119 static void
7120 destroy_info (TreeViewDragInfo *di)
7121 {
7122   g_slice_free (TreeViewDragInfo, di);
7123 }
7124
7125 static TreeViewDragInfo*
7126 ensure_info (GtkTreeView *tree_view)
7127 {
7128   TreeViewDragInfo *di;
7129
7130   di = get_info (tree_view);
7131
7132   if (di == NULL)
7133     {
7134       di = g_slice_new0 (TreeViewDragInfo);
7135
7136       g_object_set_data_full (G_OBJECT (tree_view),
7137                               I_("gtk-tree-view-drag-info"),
7138                               di,
7139                               (GDestroyNotify) destroy_info);
7140     }
7141
7142   return di;
7143 }
7144
7145 static void
7146 remove_info (GtkTreeView *tree_view)
7147 {
7148   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
7149 }
7150
7151 #if 0
7152 static gint
7153 drag_scan_timeout (gpointer data)
7154 {
7155   GtkTreeView *tree_view;
7156   gint x, y;
7157   GdkModifierType state;
7158   GtkTreePath *path = NULL;
7159   GtkTreeViewColumn *column = NULL;
7160   GdkRectangle visible_rect;
7161
7162   GDK_THREADS_ENTER ();
7163
7164   tree_view = GTK_TREE_VIEW (data);
7165
7166   gdk_window_get_device_position (tree_view->priv->bin_window,
7167                                   gdk_device_manager_get_client_pointer (
7168                                     gdk_display_get_device_manager (
7169                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
7170                                   &x, &y, &state);
7171
7172   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
7173
7174   /* See if we are near the edge. */
7175   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
7176       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
7177       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
7178       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
7179     {
7180       gtk_tree_view_get_path_at_pos (tree_view,
7181                                      tree_view->priv->bin_window,
7182                                      x, y,
7183                                      &path,
7184                                      &column,
7185                                      NULL,
7186                                      NULL);
7187
7188       if (path != NULL)
7189         {
7190           gtk_tree_view_scroll_to_cell (tree_view,
7191                                         path,
7192                                         column,
7193                                         TRUE,
7194                                         0.5, 0.5);
7195
7196           gtk_tree_path_free (path);
7197         }
7198     }
7199
7200   GDK_THREADS_LEAVE ();
7201
7202   return TRUE;
7203 }
7204 #endif /* 0 */
7205
7206 static void
7207 add_scroll_timeout (GtkTreeView *tree_view)
7208 {
7209   if (tree_view->priv->scroll_timeout == 0)
7210     {
7211       tree_view->priv->scroll_timeout =
7212         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
7213     }
7214 }
7215
7216 static void
7217 remove_scroll_timeout (GtkTreeView *tree_view)
7218 {
7219   if (tree_view->priv->scroll_timeout != 0)
7220     {
7221       g_source_remove (tree_view->priv->scroll_timeout);
7222       tree_view->priv->scroll_timeout = 0;
7223     }
7224 }
7225
7226 static gboolean
7227 check_model_dnd (GtkTreeModel *model,
7228                  GType         required_iface,
7229                  const gchar  *signal)
7230 {
7231   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
7232     {
7233       g_warning ("You must override the default '%s' handler "
7234                  "on GtkTreeView when using models that don't support "
7235                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
7236                  "is to connect to '%s' and call "
7237                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
7238                  "the default handler from running. Look at the source code "
7239                  "for the default handler in gtktreeview.c to get an idea what "
7240                  "your handler should do. (gtktreeview.c is in the GTK source "
7241                  "code.) If you're using GTK from a language other than C, "
7242                  "there may be a more natural way to override default handlers, e.g. via derivation.",
7243                  signal, g_type_name (required_iface), signal);
7244       return FALSE;
7245     }
7246   else
7247     return TRUE;
7248 }
7249
7250 static void
7251 remove_open_timeout (GtkTreeView *tree_view)
7252 {
7253   if (tree_view->priv->open_dest_timeout != 0)
7254     {
7255       g_source_remove (tree_view->priv->open_dest_timeout);
7256       tree_view->priv->open_dest_timeout = 0;
7257     }
7258 }
7259
7260
7261 static gint
7262 open_row_timeout (gpointer data)
7263 {
7264   GtkTreeView *tree_view = data;
7265   GtkTreePath *dest_path = NULL;
7266   GtkTreeViewDropPosition pos;
7267   gboolean result = FALSE;
7268
7269   gtk_tree_view_get_drag_dest_row (tree_view,
7270                                    &dest_path,
7271                                    &pos);
7272
7273   if (dest_path &&
7274       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7275        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7276     {
7277       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
7278       tree_view->priv->open_dest_timeout = 0;
7279
7280       gtk_tree_path_free (dest_path);
7281     }
7282   else
7283     {
7284       if (dest_path)
7285         gtk_tree_path_free (dest_path);
7286
7287       result = TRUE;
7288     }
7289
7290   return result;
7291 }
7292
7293 static gboolean
7294 scroll_row_timeout (gpointer data)
7295 {
7296   GtkTreeView *tree_view = data;
7297
7298   gtk_tree_view_vertical_autoscroll (tree_view);
7299
7300   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
7301     gtk_tree_view_update_rubber_band (tree_view);
7302
7303   return TRUE;
7304 }
7305
7306 /* Returns TRUE if event should not be propagated to parent widgets */
7307 static gboolean
7308 set_destination_row (GtkTreeView    *tree_view,
7309                      GdkDragContext *context,
7310                      /* coordinates relative to the widget */
7311                      gint            x,
7312                      gint            y,
7313                      GdkDragAction  *suggested_action,
7314                      GdkAtom        *target)
7315 {
7316   GtkTreePath *path = NULL;
7317   GtkTreeViewDropPosition pos;
7318   GtkTreeViewDropPosition old_pos;
7319   TreeViewDragInfo *di;
7320   GtkWidget *widget;
7321   GtkTreePath *old_dest_path = NULL;
7322   gboolean can_drop = FALSE;
7323
7324   *suggested_action = 0;
7325   *target = GDK_NONE;
7326
7327   widget = GTK_WIDGET (tree_view);
7328
7329   di = get_info (tree_view);
7330
7331   if (di == NULL || y - gtk_tree_view_get_effective_header_height (tree_view) < 0)
7332     {
7333       /* someone unset us as a drag dest, note that if
7334        * we return FALSE drag_leave isn't called
7335        */
7336
7337       gtk_tree_view_set_drag_dest_row (tree_view,
7338                                        NULL,
7339                                        GTK_TREE_VIEW_DROP_BEFORE);
7340
7341       remove_scroll_timeout (GTK_TREE_VIEW (widget));
7342       remove_open_timeout (GTK_TREE_VIEW (widget));
7343
7344       return FALSE; /* no longer a drop site */
7345     }
7346
7347   *target = gtk_drag_dest_find_target (widget, context,
7348                                        gtk_drag_dest_get_target_list (widget));
7349   if (*target == GDK_NONE)
7350     {
7351       return FALSE;
7352     }
7353
7354   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
7355                                           x, y,
7356                                           &path,
7357                                           &pos))
7358     {
7359       gint n_children;
7360       GtkTreeModel *model;
7361
7362       remove_open_timeout (tree_view);
7363
7364       /* the row got dropped on empty space, let's setup a special case
7365        */
7366
7367       if (path)
7368         gtk_tree_path_free (path);
7369
7370       model = gtk_tree_view_get_model (tree_view);
7371
7372       n_children = gtk_tree_model_iter_n_children (model, NULL);
7373       if (n_children)
7374         {
7375           pos = GTK_TREE_VIEW_DROP_AFTER;
7376           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
7377         }
7378       else
7379         {
7380           pos = GTK_TREE_VIEW_DROP_BEFORE;
7381           path = gtk_tree_path_new_from_indices (0, -1);
7382         }
7383
7384       can_drop = TRUE;
7385
7386       goto out;
7387     }
7388
7389   g_assert (path);
7390
7391   /* If we left the current row's "open" zone, unset the timeout for
7392    * opening the row
7393    */
7394   gtk_tree_view_get_drag_dest_row (tree_view,
7395                                    &old_dest_path,
7396                                    &old_pos);
7397
7398   if (old_dest_path &&
7399       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
7400        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7401          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
7402     remove_open_timeout (tree_view);
7403
7404   if (old_dest_path)
7405     gtk_tree_path_free (old_dest_path);
7406
7407   if (TRUE /* FIXME if the location droppable predicate */)
7408     {
7409       can_drop = TRUE;
7410     }
7411
7412 out:
7413   if (can_drop)
7414     {
7415       GtkWidget *source_widget;
7416
7417       *suggested_action = gdk_drag_context_get_suggested_action (context);
7418       source_widget = gtk_drag_get_source_widget (context);
7419
7420       if (source_widget == widget)
7421         {
7422           /* Default to MOVE, unless the user has
7423            * pressed ctrl or shift to affect available actions
7424            */
7425           if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
7426             *suggested_action = GDK_ACTION_MOVE;
7427         }
7428
7429       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7430                                        path, pos);
7431     }
7432   else
7433     {
7434       /* can't drop here */
7435       remove_open_timeout (tree_view);
7436
7437       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7438                                        NULL,
7439                                        GTK_TREE_VIEW_DROP_BEFORE);
7440     }
7441
7442   if (path)
7443     gtk_tree_path_free (path);
7444
7445   return TRUE;
7446 }
7447
7448 static GtkTreePath*
7449 get_logical_dest_row (GtkTreeView *tree_view,
7450                       gboolean    *path_down_mode,
7451                       gboolean    *drop_append_mode)
7452 {
7453   /* adjust path to point to the row the drop goes in front of */
7454   GtkTreePath *path = NULL;
7455   GtkTreeViewDropPosition pos;
7456
7457   g_return_val_if_fail (path_down_mode != NULL, NULL);
7458   g_return_val_if_fail (drop_append_mode != NULL, NULL);
7459
7460   *path_down_mode = FALSE;
7461   *drop_append_mode = 0;
7462
7463   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7464
7465   if (path == NULL)
7466     return NULL;
7467
7468   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
7469     ; /* do nothing */
7470   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
7471            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
7472     *path_down_mode = TRUE;
7473   else
7474     {
7475       GtkTreeIter iter;
7476       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
7477
7478       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
7479
7480       if (!gtk_tree_model_get_iter (model, &iter, path) ||
7481           !gtk_tree_model_iter_next (model, &iter))
7482         *drop_append_mode = 1;
7483       else
7484         {
7485           *drop_append_mode = 0;
7486           gtk_tree_path_next (path);
7487         }
7488     }
7489
7490   return path;
7491 }
7492
7493 static gboolean
7494 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
7495                                         GdkEventMotion   *event)
7496 {
7497   GtkWidget *widget = GTK_WIDGET (tree_view);
7498   GdkDragContext *context;
7499   TreeViewDragInfo *di;
7500   GtkTreePath *path = NULL;
7501   gint button;
7502   gint cell_x, cell_y;
7503   GtkTreeModel *model;
7504   gboolean retval = FALSE;
7505
7506   di = get_info (tree_view);
7507
7508   if (di == NULL || !di->source_set)
7509     goto out;
7510
7511   if (tree_view->priv->pressed_button < 0)
7512     goto out;
7513
7514   if (!gtk_drag_check_threshold (widget,
7515                                  tree_view->priv->press_start_x,
7516                                  tree_view->priv->press_start_y,
7517                                  event->x, event->y))
7518     goto out;
7519
7520   model = gtk_tree_view_get_model (tree_view);
7521
7522   if (model == NULL)
7523     goto out;
7524
7525   button = tree_view->priv->pressed_button;
7526   tree_view->priv->pressed_button = -1;
7527
7528   gtk_tree_view_get_path_at_pos (tree_view,
7529                                  tree_view->priv->press_start_x,
7530                                  tree_view->priv->press_start_y,
7531                                  &path,
7532                                  NULL,
7533                                  &cell_x,
7534                                  &cell_y);
7535
7536   if (path == NULL)
7537     goto out;
7538
7539   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7540       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7541                                            path))
7542     goto out;
7543
7544   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7545     goto out;
7546
7547   /* Now we can begin the drag */
7548
7549   retval = TRUE;
7550
7551   context = gtk_drag_begin (widget,
7552                             gtk_drag_source_get_target_list (widget),
7553                             di->source_actions,
7554                             button,
7555                             (GdkEvent*)event);
7556
7557   set_source_row (context, model, path);
7558
7559  out:
7560   if (path)
7561     gtk_tree_path_free (path);
7562
7563   return retval;
7564 }
7565
7566
7567 static void
7568 gtk_tree_view_drag_begin (GtkWidget      *widget,
7569                           GdkDragContext *context)
7570 {
7571   GtkTreeView *tree_view;
7572   GtkTreePath *path = NULL;
7573   gint cell_x, cell_y;
7574   cairo_surface_t *row_pix;
7575   TreeViewDragInfo *di;
7576
7577   tree_view = GTK_TREE_VIEW (widget);
7578
7579   /* if the user uses a custom DND source impl, we don't set the icon here */
7580   di = get_info (tree_view);
7581
7582   if (di == NULL || !di->source_set)
7583     return;
7584
7585   gtk_tree_view_get_path_at_pos (tree_view,
7586                                  tree_view->priv->press_start_x,
7587                                  tree_view->priv->press_start_y,
7588                                  &path,
7589                                  NULL,
7590                                  &cell_x,
7591                                  &cell_y);
7592
7593   /* If path is NULL, there's nothing we can drag.  For now, we silently
7594    * bail out.  Actually, dragging should not be possible from an empty
7595    * tree view, but there's no way we can cancel that from here.
7596    * Automatically unsetting the tree view as drag source for empty models
7597    * is something that would likely break other people's code ...
7598    */
7599   if (!path)
7600     return;
7601
7602   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7603                                                 path);
7604   cairo_surface_set_device_offset (row_pix,
7605                                    /* the + 1 is for the black border in the icon */
7606                                    - (tree_view->priv->press_start_x + 1),
7607                                    - (cell_y + 1));
7608
7609   gtk_drag_set_icon_surface (context, row_pix);
7610
7611   cairo_surface_destroy (row_pix);
7612   gtk_tree_path_free (path);
7613 }
7614
7615 static void
7616 gtk_tree_view_drag_end (GtkWidget      *widget,
7617                         GdkDragContext *context)
7618 {
7619   /* do nothing */
7620 }
7621
7622 /* Default signal implementations for the drag signals */
7623 static void
7624 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7625                              GdkDragContext   *context,
7626                              GtkSelectionData *selection_data,
7627                              guint             info,
7628                              guint             time)
7629 {
7630   GtkTreeView *tree_view;
7631   GtkTreeModel *model;
7632   TreeViewDragInfo *di;
7633   GtkTreePath *source_row;
7634
7635   tree_view = GTK_TREE_VIEW (widget);
7636
7637   model = gtk_tree_view_get_model (tree_view);
7638
7639   if (model == NULL)
7640     return;
7641
7642   di = get_info (GTK_TREE_VIEW (widget));
7643
7644   if (di == NULL)
7645     return;
7646
7647   source_row = get_source_row (context);
7648
7649   if (source_row == NULL)
7650     return;
7651
7652   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7653    * any model; for DragSource models there are some other targets
7654    * we also support.
7655    */
7656
7657   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7658       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7659                                           source_row,
7660                                           selection_data))
7661     goto done;
7662
7663   /* If drag_data_get does nothing, try providing row data. */
7664   if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7665     {
7666       gtk_tree_set_row_drag_data (selection_data,
7667                                   model,
7668                                   source_row);
7669     }
7670
7671  done:
7672   gtk_tree_path_free (source_row);
7673 }
7674
7675
7676 static void
7677 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7678                                 GdkDragContext *context)
7679 {
7680   TreeViewDragInfo *di;
7681   GtkTreeModel *model;
7682   GtkTreeView *tree_view;
7683   GtkTreePath *source_row;
7684
7685   tree_view = GTK_TREE_VIEW (widget);
7686   model = gtk_tree_view_get_model (tree_view);
7687
7688   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7689     return;
7690
7691   di = get_info (tree_view);
7692
7693   if (di == NULL)
7694     return;
7695
7696   source_row = get_source_row (context);
7697
7698   if (source_row == NULL)
7699     return;
7700
7701   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7702                                          source_row);
7703
7704   gtk_tree_path_free (source_row);
7705
7706   set_source_row (context, NULL, NULL);
7707 }
7708
7709 static void
7710 gtk_tree_view_drag_leave (GtkWidget      *widget,
7711                           GdkDragContext *context,
7712                           guint             time)
7713 {
7714   /* unset any highlight row */
7715   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7716                                    NULL,
7717                                    GTK_TREE_VIEW_DROP_BEFORE);
7718
7719   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7720   remove_open_timeout (GTK_TREE_VIEW (widget));
7721 }
7722
7723
7724 static gboolean
7725 gtk_tree_view_drag_motion (GtkWidget        *widget,
7726                            GdkDragContext   *context,
7727                            /* coordinates relative to the widget */
7728                            gint              x,
7729                            gint              y,
7730                            guint             time)
7731 {
7732   gboolean empty;
7733   GtkTreePath *path = NULL;
7734   GtkTreeViewDropPosition pos;
7735   GtkTreeView *tree_view;
7736   GdkDragAction suggested_action = 0;
7737   GdkAtom target;
7738
7739   tree_view = GTK_TREE_VIEW (widget);
7740
7741   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7742     return FALSE;
7743
7744   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7745
7746   /* we only know this *after* set_desination_row */
7747   empty = tree_view->priv->empty_view_drop;
7748
7749   if (path == NULL && !empty)
7750     {
7751       /* Can't drop here. */
7752       gdk_drag_status (context, 0, time);
7753     }
7754   else
7755     {
7756       if (tree_view->priv->open_dest_timeout == 0 &&
7757           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7758            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7759         {
7760           tree_view->priv->open_dest_timeout =
7761             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7762         }
7763       else
7764         {
7765           add_scroll_timeout (tree_view);
7766         }
7767
7768       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7769         {
7770           /* Request data so we can use the source row when
7771            * determining whether to accept the drop
7772            */
7773           set_status_pending (context, suggested_action);
7774           gtk_drag_get_data (widget, context, target, time);
7775         }
7776       else
7777         {
7778           set_status_pending (context, 0);
7779           gdk_drag_status (context, suggested_action, time);
7780         }
7781     }
7782
7783   if (path)
7784     gtk_tree_path_free (path);
7785
7786   return TRUE;
7787 }
7788
7789
7790 static gboolean
7791 gtk_tree_view_drag_drop (GtkWidget        *widget,
7792                          GdkDragContext   *context,
7793                          /* coordinates relative to the widget */
7794                          gint              x,
7795                          gint              y,
7796                          guint             time)
7797 {
7798   GtkTreeView *tree_view;
7799   GtkTreePath *path;
7800   GdkDragAction suggested_action = 0;
7801   GdkAtom target = GDK_NONE;
7802   TreeViewDragInfo *di;
7803   GtkTreeModel *model;
7804   gboolean path_down_mode;
7805   gboolean drop_append_mode;
7806
7807   tree_view = GTK_TREE_VIEW (widget);
7808
7809   model = gtk_tree_view_get_model (tree_view);
7810
7811   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7812   remove_open_timeout (GTK_TREE_VIEW (widget));
7813
7814   di = get_info (tree_view);
7815
7816   if (di == NULL)
7817     return FALSE;
7818
7819   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7820     return FALSE;
7821
7822   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7823     return FALSE;
7824
7825   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7826
7827   if (target != GDK_NONE && path != NULL)
7828     {
7829       /* in case a motion had requested drag data, change things so we
7830        * treat drag data receives as a drop.
7831        */
7832       set_status_pending (context, 0);
7833       set_dest_row (context, model, path,
7834                     path_down_mode, tree_view->priv->empty_view_drop,
7835                     drop_append_mode);
7836     }
7837
7838   if (path)
7839     gtk_tree_path_free (path);
7840
7841   /* Unset this thing */
7842   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7843                                    NULL,
7844                                    GTK_TREE_VIEW_DROP_BEFORE);
7845
7846   if (target != GDK_NONE)
7847     {
7848       gtk_drag_get_data (widget, context, target, time);
7849       return TRUE;
7850     }
7851   else
7852     return FALSE;
7853 }
7854
7855 static void
7856 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7857                                   GdkDragContext   *context,
7858                                   /* coordinates relative to the widget */
7859                                   gint              x,
7860                                   gint              y,
7861                                   GtkSelectionData *selection_data,
7862                                   guint             info,
7863                                   guint             time)
7864 {
7865   GtkTreePath *path;
7866   TreeViewDragInfo *di;
7867   gboolean accepted = FALSE;
7868   GtkTreeModel *model;
7869   GtkTreeView *tree_view;
7870   GtkTreePath *dest_row;
7871   GdkDragAction suggested_action;
7872   gboolean path_down_mode;
7873   gboolean drop_append_mode;
7874
7875   tree_view = GTK_TREE_VIEW (widget);
7876
7877   model = gtk_tree_view_get_model (tree_view);
7878
7879   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7880     return;
7881
7882   di = get_info (tree_view);
7883
7884   if (di == NULL)
7885     return;
7886
7887   suggested_action = get_status_pending (context);
7888
7889   if (suggested_action)
7890     {
7891       /* We are getting this data due to a request in drag_motion,
7892        * rather than due to a request in drag_drop, so we are just
7893        * supposed to call drag_status, not actually paste in the
7894        * data.
7895        */
7896       path = get_logical_dest_row (tree_view, &path_down_mode,
7897                                    &drop_append_mode);
7898
7899       if (path == NULL)
7900         suggested_action = 0;
7901       else if (path_down_mode)
7902         gtk_tree_path_down (path);
7903
7904       if (suggested_action)
7905         {
7906           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7907                                                      path,
7908                                                      selection_data))
7909             {
7910               if (path_down_mode)
7911                 {
7912                   path_down_mode = FALSE;
7913                   gtk_tree_path_up (path);
7914
7915                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7916                                                              path,
7917                                                              selection_data))
7918                     suggested_action = 0;
7919                 }
7920               else
7921                 suggested_action = 0;
7922             }
7923         }
7924
7925       gdk_drag_status (context, suggested_action, time);
7926
7927       if (path)
7928         gtk_tree_path_free (path);
7929
7930       /* If you can't drop, remove user drop indicator until the next motion */
7931       if (suggested_action == 0)
7932         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7933                                          NULL,
7934                                          GTK_TREE_VIEW_DROP_BEFORE);
7935
7936       return;
7937     }
7938
7939   dest_row = get_dest_row (context, &path_down_mode);
7940
7941   if (dest_row == NULL)
7942     return;
7943
7944   if (gtk_selection_data_get_length (selection_data) >= 0)
7945     {
7946       if (path_down_mode)
7947         {
7948           gtk_tree_path_down (dest_row);
7949           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7950                                                      dest_row, selection_data))
7951             gtk_tree_path_up (dest_row);
7952         }
7953     }
7954
7955   if (gtk_selection_data_get_length (selection_data) >= 0)
7956     {
7957       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
7958                                                  dest_row,
7959                                                  selection_data))
7960         accepted = TRUE;
7961     }
7962
7963   gtk_drag_finish (context,
7964                    accepted,
7965                    (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
7966                    time);
7967
7968   if (gtk_tree_path_get_depth (dest_row) == 1 &&
7969       gtk_tree_path_get_indices (dest_row)[0] == 0 &&
7970       gtk_tree_model_iter_n_children (tree_view->priv->model, NULL) != 0)
7971     {
7972       /* special special case drag to "0", scroll to first item */
7973       if (!tree_view->priv->scroll_to_path)
7974         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
7975     }
7976
7977   gtk_tree_path_free (dest_row);
7978
7979   /* drop dest_row */
7980   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
7981 }
7982
7983
7984
7985 /* GtkContainer Methods
7986  */
7987
7988
7989 static void
7990 gtk_tree_view_remove (GtkContainer *container,
7991                       GtkWidget    *widget)
7992 {
7993   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7994   GtkTreeViewChild *child = NULL;
7995   GList *tmp_list;
7996
7997   tmp_list = tree_view->priv->children;
7998   while (tmp_list)
7999     {
8000       child = tmp_list->data;
8001       if (child->widget == widget)
8002         {
8003           gtk_widget_unparent (widget);
8004
8005           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
8006           g_list_free_1 (tmp_list);
8007           g_slice_free (GtkTreeViewChild, child);
8008           return;
8009         }
8010
8011       tmp_list = tmp_list->next;
8012     }
8013
8014   tmp_list = tree_view->priv->columns;
8015
8016   while (tmp_list)
8017     {
8018       GtkTreeViewColumn *column;
8019       GtkWidget         *button;
8020
8021       column = tmp_list->data;
8022       button = gtk_tree_view_column_get_button (column);
8023
8024       if (button == widget)
8025         {
8026           gtk_widget_unparent (widget);
8027           return;
8028         }
8029       tmp_list = tmp_list->next;
8030     }
8031 }
8032
8033 static void
8034 gtk_tree_view_forall (GtkContainer *container,
8035                       gboolean      include_internals,
8036                       GtkCallback   callback,
8037                       gpointer      callback_data)
8038 {
8039   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8040   GtkTreeViewChild *child = NULL;
8041   GtkTreeViewColumn *column;
8042   GtkWidget *button;
8043   GList *tmp_list;
8044
8045   tmp_list = tree_view->priv->children;
8046   while (tmp_list)
8047     {
8048       child = tmp_list->data;
8049       tmp_list = tmp_list->next;
8050
8051       (* callback) (child->widget, callback_data);
8052     }
8053   if (include_internals == FALSE)
8054     return;
8055
8056   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8057     {
8058       column = tmp_list->data;
8059       button = gtk_tree_view_column_get_button (column);
8060
8061       if (button)
8062         (* callback) (button, callback_data);
8063     }
8064 }
8065
8066 /* Returns TRUE is any of the columns contains a cell that can-focus.
8067  * If this is not the case, a column-spanning focus rectangle will be
8068  * drawn.
8069  */
8070 static gboolean
8071 gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view)
8072 {
8073   GList *list;
8074
8075   for (list = tree_view->priv->columns; list; list = list->next)
8076     {
8077       GtkTreeViewColumn *column = list->data;
8078
8079       if (!gtk_tree_view_column_get_visible (column))
8080         continue;
8081       if (gtk_cell_area_is_activatable (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column))))
8082         return TRUE;
8083     }
8084
8085   return FALSE;
8086 }
8087
8088 static void
8089 column_sizing_notify (GObject    *object,
8090                       GParamSpec *pspec,
8091                       gpointer    data)
8092 {
8093   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
8094
8095   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
8096     /* disable fixed height mode */
8097     g_object_set (data, "fixed-height-mode", FALSE, NULL);
8098 }
8099
8100 /**
8101  * gtk_tree_view_set_fixed_height_mode:
8102  * @tree_view: a #GtkTreeView
8103  * @enable: %TRUE to enable fixed height mode
8104  *
8105  * Enables or disables the fixed height mode of @tree_view.
8106  * Fixed height mode speeds up #GtkTreeView by assuming that all
8107  * rows have the same height.
8108  * Only enable this option if all rows are the same height and all
8109  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
8110  *
8111  * Since: 2.6
8112  **/
8113 void
8114 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
8115                                      gboolean     enable)
8116 {
8117   GList *l;
8118
8119   enable = enable != FALSE;
8120
8121   if (enable == tree_view->priv->fixed_height_mode)
8122     return;
8123
8124   if (!enable)
8125     {
8126       tree_view->priv->fixed_height_mode = 0;
8127       tree_view->priv->fixed_height = -1;
8128
8129       /* force a revalidation */
8130       install_presize_handler (tree_view);
8131     }
8132   else
8133     {
8134       /* make sure all columns are of type FIXED */
8135       for (l = tree_view->priv->columns; l; l = l->next)
8136         {
8137           GtkTreeViewColumn *c = l->data;
8138
8139           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
8140         }
8141
8142       /* yes, we really have to do this is in a separate loop */
8143       for (l = tree_view->priv->columns; l; l = l->next)
8144         g_signal_connect (l->data, "notify::sizing",
8145                           G_CALLBACK (column_sizing_notify), tree_view);
8146
8147       tree_view->priv->fixed_height_mode = 1;
8148       tree_view->priv->fixed_height = -1;
8149
8150       if (tree_view->priv->tree)
8151         initialize_fixed_height_mode (tree_view);
8152     }
8153
8154   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
8155 }
8156
8157 /**
8158  * gtk_tree_view_get_fixed_height_mode:
8159  * @tree_view: a #GtkTreeView
8160  *
8161  * Returns whether fixed height mode is turned on for @tree_view.
8162  *
8163  * Return value: %TRUE if @tree_view is in fixed height mode
8164  *
8165  * Since: 2.6
8166  **/
8167 gboolean
8168 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
8169 {
8170   return tree_view->priv->fixed_height_mode;
8171 }
8172
8173 /* Returns TRUE if the focus is within the headers, after the focus operation is
8174  * done
8175  */
8176 static gboolean
8177 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
8178                             GtkDirectionType  dir,
8179                             gboolean          clamp_column_visible)
8180 {
8181   GtkTreeViewColumn *column;
8182   GtkWidget *focus_child;
8183   GtkWidget *button;
8184   GList *last_column, *first_column;
8185   GList *tmp_list;
8186   gboolean rtl;
8187
8188   if (! tree_view->priv->headers_visible)
8189     return FALSE;
8190
8191   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
8192
8193   first_column = tree_view->priv->columns;
8194   while (first_column)
8195     {
8196       column = GTK_TREE_VIEW_COLUMN (first_column->data);
8197       button = gtk_tree_view_column_get_button (column);
8198
8199       if (gtk_widget_get_can_focus (button) &&
8200           gtk_tree_view_column_get_visible (column) &&
8201           (gtk_tree_view_column_get_clickable (column) ||
8202            gtk_tree_view_column_get_reorderable (column)))
8203         break;
8204       first_column = first_column->next;
8205     }
8206
8207   /* No headers are visible, or are focusable.  We can't focus in or out.
8208    */
8209   if (first_column == NULL)
8210     return FALSE;
8211
8212   last_column = g_list_last (tree_view->priv->columns);
8213   while (last_column)
8214     {
8215       column = GTK_TREE_VIEW_COLUMN (last_column->data);
8216       button = gtk_tree_view_column_get_button (column);
8217
8218       if (gtk_widget_get_can_focus (button) &&
8219           gtk_tree_view_column_get_visible (column) &&
8220           (gtk_tree_view_column_get_clickable (column) ||
8221            gtk_tree_view_column_get_reorderable (column)))
8222         break;
8223       last_column = last_column->prev;
8224     }
8225
8226
8227   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8228
8229   switch (dir)
8230     {
8231     case GTK_DIR_TAB_BACKWARD:
8232     case GTK_DIR_TAB_FORWARD:
8233     case GTK_DIR_UP:
8234     case GTK_DIR_DOWN:
8235       if (focus_child == NULL)
8236         {
8237           if (tree_view->priv->focus_column != NULL)
8238             button = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8239           else
8240             button = NULL;
8241
8242           if (button && gtk_widget_get_can_focus (button))
8243             focus_child = button;
8244           else
8245             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8246
8247           gtk_widget_grab_focus (focus_child);
8248           break;
8249         }
8250       return FALSE;
8251
8252     case GTK_DIR_LEFT:
8253     case GTK_DIR_RIGHT:
8254       if (focus_child == NULL)
8255         {
8256           if (tree_view->priv->focus_column != NULL)
8257             focus_child = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8258           else if (dir == GTK_DIR_LEFT)
8259             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (last_column->data));
8260           else
8261             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8262
8263           gtk_widget_grab_focus (focus_child);
8264           break;
8265         }
8266
8267       if (gtk_widget_child_focus (focus_child, dir))
8268         {
8269           /* The focus moves inside the button. */
8270           /* This is probably a great example of bad UI */
8271           break;
8272         }
8273
8274       /* We need to move the focus among the row of buttons. */
8275       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8276         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8277           break;
8278
8279       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
8280           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
8281         {
8282           gtk_widget_error_bell (GTK_WIDGET (tree_view));
8283           break;
8284         }
8285
8286       while (tmp_list)
8287         {
8288           GtkTreeViewColumn *column;
8289           GtkWidget         *button;
8290
8291           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
8292             tmp_list = tmp_list->next;
8293           else
8294             tmp_list = tmp_list->prev;
8295
8296           if (tmp_list == NULL)
8297             {
8298               g_warning ("Internal button not found");
8299               break;
8300             }
8301           column = tmp_list->data;
8302           button = gtk_tree_view_column_get_button (column);
8303           if (button &&
8304               gtk_tree_view_column_get_visible (column) &&
8305               gtk_widget_get_can_focus (button))
8306             {
8307               focus_child = button;
8308               gtk_widget_grab_focus (button);
8309               break;
8310             }
8311         }
8312       break;
8313     default:
8314       g_assert_not_reached ();
8315       break;
8316     }
8317
8318   /* if focus child is non-null, we assume it's been set to the current focus child
8319    */
8320   if (focus_child)
8321     {
8322       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8323         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8324           {
8325             _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (tmp_list->data));
8326             break;
8327           }
8328
8329       if (clamp_column_visible)
8330         {
8331           gtk_tree_view_clamp_column_visible (tree_view,
8332                                               tree_view->priv->focus_column,
8333                                               FALSE);
8334         }
8335     }
8336
8337   return (focus_child != NULL);
8338 }
8339
8340 /* This function returns in 'path' the first focusable path, if the given path
8341  * is already focusable, it's the returned one.
8342  */
8343 static gboolean
8344 search_first_focusable_path (GtkTreeView  *tree_view,
8345                              GtkTreePath **path,
8346                              gboolean      search_forward,
8347                              GtkRBTree   **new_tree,
8348                              GtkRBNode   **new_node)
8349 {
8350   GtkRBTree *tree = NULL;
8351   GtkRBNode *node = NULL;
8352
8353   if (!path || !*path)
8354     return FALSE;
8355
8356   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
8357
8358   if (!tree || !node)
8359     return FALSE;
8360
8361   while (node && row_is_separator (tree_view, NULL, *path))
8362     {
8363       if (search_forward)
8364         _gtk_rbtree_next_full (tree, node, &tree, &node);
8365       else
8366         _gtk_rbtree_prev_full (tree, node, &tree, &node);
8367
8368       if (*path)
8369         gtk_tree_path_free (*path);
8370
8371       if (node)
8372         *path = _gtk_tree_path_new_from_rbtree (tree, node);
8373       else
8374         *path = NULL;
8375     }
8376
8377   if (new_tree)
8378     *new_tree = tree;
8379
8380   if (new_node)
8381     *new_node = node;
8382
8383   return (*path != NULL);
8384 }
8385
8386 static gint
8387 gtk_tree_view_focus (GtkWidget        *widget,
8388                      GtkDirectionType  direction)
8389 {
8390   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8391   GtkContainer *container = GTK_CONTAINER (widget);
8392   GtkWidget *focus_child;
8393
8394   if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
8395     return FALSE;
8396
8397   focus_child = gtk_container_get_focus_child (container);
8398
8399   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
8400   /* Case 1.  Headers currently have focus. */
8401   if (focus_child)
8402     {
8403       switch (direction)
8404         {
8405         case GTK_DIR_LEFT:
8406         case GTK_DIR_RIGHT:
8407           gtk_tree_view_header_focus (tree_view, direction, TRUE);
8408           return TRUE;
8409         case GTK_DIR_TAB_BACKWARD:
8410         case GTK_DIR_UP:
8411           return FALSE;
8412         case GTK_DIR_TAB_FORWARD:
8413         case GTK_DIR_DOWN:
8414           gtk_widget_grab_focus (widget);
8415           return TRUE;
8416         default:
8417           g_assert_not_reached ();
8418           return FALSE;
8419         }
8420     }
8421
8422   /* Case 2. We don't have focus at all. */
8423   if (!gtk_widget_has_focus (widget))
8424     {
8425       gtk_widget_grab_focus (widget);
8426       return TRUE;
8427     }
8428
8429   /* Case 3. We have focus already. */
8430   if (direction == GTK_DIR_TAB_BACKWARD)
8431     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
8432   else if (direction == GTK_DIR_TAB_FORWARD)
8433     return FALSE;
8434
8435   /* Other directions caught by the keybindings */
8436   gtk_widget_grab_focus (widget);
8437   return TRUE;
8438 }
8439
8440 static void
8441 gtk_tree_view_grab_focus (GtkWidget *widget)
8442 {
8443   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
8444
8445   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
8446 }
8447
8448 static void
8449 gtk_tree_view_style_updated (GtkWidget *widget)
8450 {
8451   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8452   GList *list;
8453   GtkTreeViewColumn *column;
8454
8455   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->style_updated (widget);
8456
8457   if (gtk_widget_get_realized (widget))
8458     {
8459       gtk_tree_view_ensure_background (tree_view);
8460
8461       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
8462       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
8463     }
8464
8465   gtk_widget_style_get (widget,
8466                         "expander-size", &tree_view->priv->expander_size,
8467                         NULL);
8468   tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
8469
8470   for (list = tree_view->priv->columns; list; list = list->next)
8471     {
8472       column = list->data;
8473       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8474     }
8475
8476   tree_view->priv->fixed_height = -1;
8477   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
8478
8479   gtk_widget_queue_resize (widget);
8480 }
8481
8482
8483 static void
8484 gtk_tree_view_set_focus_child (GtkContainer *container,
8485                                GtkWidget    *child)
8486 {
8487   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8488   GList *list;
8489
8490   for (list = tree_view->priv->columns; list; list = list->next)
8491     {
8492       if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child)
8493         {
8494           _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
8495           break;
8496         }
8497     }
8498
8499   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
8500 }
8501
8502 static GtkWidgetPath *
8503 gtk_tree_view_get_path_for_child (GtkContainer *container,
8504                                   GtkWidget    *child)
8505 {
8506   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8507   GtkWidgetPath *path;
8508   gboolean rtl;
8509   GList *list;
8510   gint n_col = 0;
8511
8512   path = GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->get_path_for_child (container, child);
8513   rtl = (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL);
8514
8515   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
8516        list;
8517        list = (rtl ? list->prev : list->next))
8518     {
8519       GtkTreeViewColumn *column = list->data;
8520       GtkRegionFlags flags = 0;
8521
8522       if (!gtk_tree_view_column_get_visible (column))
8523         continue;
8524
8525       n_col++;
8526
8527       if (gtk_tree_view_column_get_widget (column) != child &&
8528           gtk_tree_view_column_get_button (column) != child)
8529         continue;
8530
8531       if ((n_col % 2) == 0)
8532         flags |= GTK_REGION_EVEN;
8533       else
8534         flags |= GTK_REGION_ODD;
8535
8536       if (n_col == 1)
8537         flags |= GTK_REGION_FIRST;
8538
8539       if ((rtl && !list->prev) ||
8540           (!rtl && !list->next))
8541         flags |= GTK_REGION_LAST;
8542
8543       gtk_widget_path_iter_add_region (path, -1, GTK_STYLE_REGION_COLUMN_HEADER, flags);
8544       break;
8545     }
8546
8547   gtk_widget_path_append_for_widget (path, child);
8548
8549   return path;
8550 }
8551
8552 static gboolean
8553 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8554                                 GtkMovementStep    step,
8555                                 gint               count)
8556 {
8557   GdkModifierType state;
8558
8559   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8560   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8561                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8562                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8563                         step == GTK_MOVEMENT_PAGES ||
8564                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8565
8566   if (tree_view->priv->tree == NULL)
8567     return FALSE;
8568   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8569     return FALSE;
8570
8571   gtk_tree_view_stop_editing (tree_view, FALSE);
8572   tree_view->priv->draw_keyfocus = TRUE;
8573   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8574
8575   if (gtk_get_current_event_state (&state))
8576     {
8577       GdkModifierType extend_mod_mask;
8578       GdkModifierType modify_mod_mask;
8579
8580       extend_mod_mask =
8581         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8582                                       GDK_MODIFIER_INTENT_EXTEND_SELECTION);
8583
8584       modify_mod_mask =
8585         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8586                                       GDK_MODIFIER_INTENT_MODIFY_SELECTION);
8587
8588       if ((state & modify_mod_mask) == modify_mod_mask)
8589         tree_view->priv->modify_selection_pressed = TRUE;
8590       if ((state & extend_mod_mask) == extend_mod_mask)
8591         tree_view->priv->extend_selection_pressed = TRUE;
8592     }
8593   /* else we assume not pressed */
8594
8595   switch (step)
8596     {
8597       /* currently we make no distinction.  When we go bi-di, we need to */
8598     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8599     case GTK_MOVEMENT_VISUAL_POSITIONS:
8600       gtk_tree_view_move_cursor_left_right (tree_view, count);
8601       break;
8602     case GTK_MOVEMENT_DISPLAY_LINES:
8603       gtk_tree_view_move_cursor_up_down (tree_view, count);
8604       break;
8605     case GTK_MOVEMENT_PAGES:
8606       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8607       break;
8608     case GTK_MOVEMENT_BUFFER_ENDS:
8609       gtk_tree_view_move_cursor_start_end (tree_view, count);
8610       break;
8611     default:
8612       g_assert_not_reached ();
8613     }
8614
8615   tree_view->priv->modify_selection_pressed = FALSE;
8616   tree_view->priv->extend_selection_pressed = FALSE;
8617
8618   return TRUE;
8619 }
8620
8621 static void
8622 gtk_tree_view_put (GtkTreeView *tree_view,
8623                    GtkWidget   *child_widget,
8624                    /* in bin_window coordinates */
8625                    gint         x,
8626                    gint         y,
8627                    gint         width,
8628                    gint         height)
8629 {
8630   GtkTreeViewChild *child;
8631
8632   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8633   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8634
8635   child = g_slice_new (GtkTreeViewChild);
8636
8637   child->widget = child_widget;
8638   child->x = x;
8639   child->y = y;
8640   child->width = width;
8641   child->height = height;
8642
8643   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8644
8645   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8646     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8647
8648   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8649 }
8650
8651 void
8652 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8653                                   GtkWidget   *widget,
8654                                   /* in tree coordinates */
8655                                   gint         x,
8656                                   gint         y,
8657                                   gint         width,
8658                                   gint         height)
8659 {
8660   GtkTreeViewChild *child = NULL;
8661   GList *list;
8662   GdkRectangle allocation;
8663
8664   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8665   g_return_if_fail (GTK_IS_WIDGET (widget));
8666
8667   for (list = tree_view->priv->children; list; list = list->next)
8668     {
8669       if (((GtkTreeViewChild *)list->data)->widget == widget)
8670         {
8671           child = list->data;
8672           break;
8673         }
8674     }
8675   if (child == NULL)
8676     return;
8677
8678   allocation.x = child->x = x;
8679   allocation.y = child->y = y;
8680   allocation.width = child->width = width;
8681   allocation.height = child->height = height;
8682
8683   if (gtk_widget_get_realized (widget))
8684     gtk_widget_size_allocate (widget, &allocation);
8685 }
8686
8687
8688 /* TreeModel Callbacks
8689  */
8690
8691 static void
8692 gtk_tree_view_row_changed (GtkTreeModel *model,
8693                            GtkTreePath  *path,
8694                            GtkTreeIter  *iter,
8695                            gpointer      data)
8696 {
8697   GtkTreeView *tree_view = (GtkTreeView *)data;
8698   GtkRBTree *tree;
8699   GtkRBNode *node;
8700   gboolean free_path = FALSE;
8701   GList *list;
8702   GtkTreePath *cursor_path;
8703
8704   g_return_if_fail (path != NULL || iter != NULL);
8705
8706   if (tree_view->priv->cursor_node != NULL)
8707     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
8708                                                   tree_view->priv->cursor_node);
8709   else
8710     cursor_path = NULL;
8711
8712   if (tree_view->priv->edited_column &&
8713       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8714     gtk_tree_view_stop_editing (tree_view, TRUE);
8715
8716   if (cursor_path != NULL)
8717     gtk_tree_path_free (cursor_path);
8718
8719   if (path == NULL)
8720     {
8721       path = gtk_tree_model_get_path (model, iter);
8722       free_path = TRUE;
8723     }
8724   else if (iter == NULL)
8725     gtk_tree_model_get_iter (model, iter, path);
8726
8727   if (_gtk_tree_view_find_node (tree_view,
8728                                 path,
8729                                 &tree,
8730                                 &node))
8731     /* We aren't actually showing the node */
8732     goto done;
8733
8734   if (tree == NULL)
8735     goto done;
8736
8737   _gtk_tree_view_accessible_changed (tree_view, tree, node);
8738
8739   if (tree_view->priv->fixed_height_mode
8740       && tree_view->priv->fixed_height >= 0)
8741     {
8742       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8743       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8744         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8745     }
8746   else
8747     {
8748       _gtk_rbtree_node_mark_invalid (tree, node);
8749       for (list = tree_view->priv->columns; list; list = list->next)
8750         {
8751           GtkTreeViewColumn *column;
8752
8753           column = list->data;
8754           if (!gtk_tree_view_column_get_visible (column))
8755             continue;
8756
8757           if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8758             {
8759               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8760             }
8761         }
8762     }
8763
8764  done:
8765   if (!tree_view->priv->fixed_height_mode &&
8766       gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8767     install_presize_handler (tree_view);
8768   if (free_path)
8769     gtk_tree_path_free (path);
8770 }
8771
8772 static void
8773 gtk_tree_view_row_inserted (GtkTreeModel *model,
8774                             GtkTreePath  *path,
8775                             GtkTreeIter  *iter,
8776                             gpointer      data)
8777 {
8778   GtkTreeView *tree_view = (GtkTreeView *) data;
8779   gint *indices;
8780   GtkRBTree *tree;
8781   GtkRBNode *tmpnode = NULL;
8782   gint depth;
8783   gint i = 0;
8784   gint height;
8785   gboolean free_path = FALSE;
8786   gboolean node_visible = TRUE;
8787
8788   g_return_if_fail (path != NULL || iter != NULL);
8789
8790   if (tree_view->priv->fixed_height_mode
8791       && tree_view->priv->fixed_height >= 0)
8792     height = tree_view->priv->fixed_height;
8793   else
8794     height = 0;
8795
8796   if (path == NULL)
8797     {
8798       path = gtk_tree_model_get_path (model, iter);
8799       free_path = TRUE;
8800     }
8801   else if (iter == NULL)
8802     gtk_tree_model_get_iter (model, iter, path);
8803
8804   if (tree_view->priv->tree == NULL)
8805     tree_view->priv->tree = _gtk_rbtree_new ();
8806
8807   tree = tree_view->priv->tree;
8808
8809   /* Update all row-references */
8810   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8811   depth = gtk_tree_path_get_depth (path);
8812   indices = gtk_tree_path_get_indices (path);
8813
8814   /* First, find the parent tree */
8815   while (i < depth - 1)
8816     {
8817       if (tree == NULL)
8818         {
8819           /* We aren't showing the node */
8820           node_visible = FALSE;
8821           goto done;
8822         }
8823
8824       tmpnode = _gtk_rbtree_find_count (tree, indices[i] + 1);
8825       if (tmpnode == NULL)
8826         {
8827           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8828                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8829                      "before the parent was inserted.");
8830           goto done;
8831         }
8832       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8833         {
8834           /* FIXME enforce correct behavior on model, probably */
8835           /* In theory, the model should have emitted has_child_toggled here.  We
8836            * try to catch it anyway, just to be safe, in case the model hasn't.
8837            */
8838           GtkTreePath *tmppath = _gtk_tree_path_new_from_rbtree (tree, tmpnode);
8839           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8840           gtk_tree_path_free (tmppath);
8841           goto done;
8842         }
8843
8844       tree = tmpnode->children;
8845       i++;
8846     }
8847
8848   if (tree == NULL)
8849     {
8850       node_visible = FALSE;
8851       goto done;
8852     }
8853
8854   /* ref the node */
8855   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8856   if (indices[depth - 1] == 0)
8857     {
8858       tmpnode = _gtk_rbtree_find_count (tree, 1);
8859       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8860     }
8861   else
8862     {
8863       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8864       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8865     }
8866
8867   _gtk_tree_view_accessible_add (tree_view, tree, tmpnode);
8868
8869  done:
8870   if (height > 0)
8871     {
8872       if (tree)
8873         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8874
8875       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8876         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8877       else
8878         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8879     }
8880   else
8881     install_presize_handler (tree_view);
8882   if (free_path)
8883     gtk_tree_path_free (path);
8884 }
8885
8886 static void
8887 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8888                                      GtkTreePath  *path,
8889                                      GtkTreeIter  *iter,
8890                                      gpointer      data)
8891 {
8892   GtkTreeView *tree_view = (GtkTreeView *)data;
8893   GtkTreeIter real_iter;
8894   gboolean has_child;
8895   GtkRBTree *tree;
8896   GtkRBNode *node;
8897   gboolean free_path = FALSE;
8898
8899   g_return_if_fail (path != NULL || iter != NULL);
8900
8901   if (iter)
8902     real_iter = *iter;
8903
8904   if (path == NULL)
8905     {
8906       path = gtk_tree_model_get_path (model, iter);
8907       free_path = TRUE;
8908     }
8909   else if (iter == NULL)
8910     gtk_tree_model_get_iter (model, &real_iter, path);
8911
8912   if (_gtk_tree_view_find_node (tree_view,
8913                                 path,
8914                                 &tree,
8915                                 &node))
8916     /* We aren't actually showing the node */
8917     goto done;
8918
8919   if (tree == NULL)
8920     goto done;
8921
8922   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8923   /* Sanity check.
8924    */
8925   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8926     goto done;
8927
8928   if (has_child)
8929     {
8930       GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8931       _gtk_tree_view_accessible_add_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8932     }
8933   else
8934     {
8935       GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8936       _gtk_tree_view_accessible_remove_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8937     }
8938
8939   if (has_child && tree_view->priv->is_list)
8940     {
8941       tree_view->priv->is_list = FALSE;
8942       if (tree_view->priv->show_expanders)
8943         {
8944           GList *list;
8945
8946           for (list = tree_view->priv->columns; list; list = list->next)
8947             if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
8948               {
8949                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8950                 break;
8951               }
8952         }
8953       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8954     }
8955   else
8956     {
8957       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8958     }
8959
8960  done:
8961   if (free_path)
8962     gtk_tree_path_free (path);
8963 }
8964
8965 static void
8966 count_children_helper (GtkRBTree *tree,
8967                        GtkRBNode *node,
8968                        gpointer   data)
8969 {
8970   if (node->children)
8971     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8972   (*((gint *)data))++;
8973 }
8974
8975 static void
8976 check_selection_helper (GtkRBTree *tree,
8977                         GtkRBNode *node,
8978                         gpointer   data)
8979 {
8980   gint *value = (gint *)data;
8981
8982   *value |= GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8983
8984   if (node->children && !*value)
8985     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8986 }
8987
8988 static void
8989 gtk_tree_view_row_deleted (GtkTreeModel *model,
8990                            GtkTreePath  *path,
8991                            gpointer      data)
8992 {
8993   GtkTreeView *tree_view = (GtkTreeView *)data;
8994   GtkRBTree *tree;
8995   GtkRBNode *node;
8996   GList *list;
8997   gboolean selection_changed = FALSE, cursor_changed = FALSE;
8998   GtkRBTree *cursor_tree = NULL;
8999   GtkRBNode *cursor_node = NULL;
9000   GtkStyleContext *context;
9001
9002   g_return_if_fail (path != NULL);
9003
9004   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
9005
9006   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
9007     return;
9008
9009   if (tree == NULL)
9010     return;
9011
9012   /* check if the selection has been changed */
9013   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
9014                         check_selection_helper, &selection_changed);
9015
9016   for (list = tree_view->priv->columns; list; list = list->next)
9017     if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)) &&
9018         gtk_tree_view_column_get_sizing (GTK_TREE_VIEW_COLUMN (list->data)) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9019       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
9020
9021   /* Ensure we don't have a dangling pointer to a dead node */
9022   ensure_unprelighted (tree_view);
9023
9024   /* Cancel editting if we've started */
9025   gtk_tree_view_stop_editing (tree_view, TRUE);
9026
9027   /* If the cursor row got deleted, move the cursor to the next row */
9028   if (tree_view->priv->cursor_node &&
9029       (tree_view->priv->cursor_node == node ||
9030        (node->children && (tree_view->priv->cursor_tree == node->children ||
9031                            _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree)))))
9032     {
9033       GtkTreePath *cursor_path;
9034
9035       cursor_tree = tree;
9036       cursor_node = _gtk_rbtree_next (tree, node);
9037       /* find the first node that is not going to be deleted */
9038       while (cursor_node == NULL && cursor_tree->parent_tree)
9039         {
9040           cursor_node = _gtk_rbtree_next (cursor_tree->parent_tree,
9041                                           cursor_tree->parent_node);
9042           cursor_tree = cursor_tree->parent_tree;
9043         }
9044
9045       if (cursor_node != NULL)
9046         cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9047       else
9048         cursor_path = NULL;
9049
9050       if (cursor_path == NULL ||
9051           ! search_first_focusable_path (tree_view, &cursor_path, TRUE,
9052                                          &cursor_tree, &cursor_node))
9053         {
9054           /* It looks like we reached the end of the view without finding
9055            * a focusable row.  We will step backwards to find the last
9056            * focusable row.
9057            */
9058           _gtk_rbtree_prev_full (tree, node, &cursor_tree, &cursor_node);
9059           if (cursor_node)
9060             {
9061               cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9062               if (! search_first_focusable_path (tree_view, &cursor_path, FALSE,
9063                                                  &cursor_tree, &cursor_node))
9064                 cursor_node = NULL;
9065               gtk_tree_path_free (cursor_path);
9066             }
9067         }
9068       else if (cursor_path)
9069         gtk_tree_path_free (cursor_path);
9070
9071       cursor_changed = TRUE;
9072     }
9073
9074   if (tree_view->priv->destroy_count_func)
9075     {
9076       gint child_count = 0;
9077       if (node->children)
9078         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
9079       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
9080     }
9081
9082   if (tree->root->count == 1)
9083     {
9084       if (tree_view->priv->tree == tree)
9085         tree_view->priv->tree = NULL;
9086
9087       _gtk_tree_view_accessible_remove_state (tree_view,
9088                                               tree->parent_tree, tree->parent_node,
9089                                               GTK_CELL_RENDERER_EXPANDED);
9090       _gtk_tree_view_accessible_remove (tree_view, tree, NULL);
9091       _gtk_rbtree_remove (tree);
9092     }
9093   else
9094     {
9095       _gtk_tree_view_accessible_remove (tree_view, tree, node);
9096       _gtk_rbtree_remove_node (tree, node);
9097     }
9098
9099   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
9100     {
9101       gtk_tree_row_reference_free (tree_view->priv->top_row);
9102       tree_view->priv->top_row = NULL;
9103     }
9104
9105   /* Cancel any ongoing animation happening within the row */
9106   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
9107   gtk_style_context_cancel_animations (context, node);
9108
9109   install_scroll_sync_handler (tree_view);
9110
9111   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9112
9113   if (cursor_changed)
9114     {
9115       if (cursor_node)
9116         {
9117           GtkTreePath *cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9118           gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CURSOR_INVALID);
9119           gtk_tree_path_free (cursor_path);
9120         }
9121       else
9122         gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT | CURSOR_INVALID);
9123     }
9124   if (selection_changed)
9125     g_signal_emit_by_name (tree_view->priv->selection, "changed");
9126 }
9127
9128 static void
9129 gtk_tree_view_rows_reordered (GtkTreeModel *model,
9130                               GtkTreePath  *parent,
9131                               GtkTreeIter  *iter,
9132                               gint         *new_order,
9133                               gpointer      data)
9134 {
9135   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
9136   GtkRBTree *tree;
9137   GtkRBNode *node;
9138   gint len;
9139
9140   len = gtk_tree_model_iter_n_children (model, iter);
9141
9142   if (len < 2)
9143     return;
9144
9145   gtk_tree_row_reference_reordered (G_OBJECT (data),
9146                                     parent,
9147                                     iter,
9148                                     new_order);
9149
9150   if (_gtk_tree_view_find_node (tree_view,
9151                                 parent,
9152                                 &tree,
9153                                 &node))
9154     return;
9155
9156   /* We need to special case the parent path */
9157   if (tree == NULL)
9158     tree = tree_view->priv->tree;
9159   else
9160     tree = node->children;
9161
9162   if (tree == NULL)
9163     return;
9164
9165   if (tree_view->priv->edited_column)
9166     gtk_tree_view_stop_editing (tree_view, TRUE);
9167
9168   /* we need to be unprelighted */
9169   ensure_unprelighted (tree_view);
9170
9171   _gtk_rbtree_reorder (tree, new_order, len);
9172
9173   _gtk_tree_view_accessible_reorder (tree_view);
9174
9175   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
9176
9177   gtk_tree_view_dy_to_top_row (tree_view);
9178 }
9179
9180
9181 /* Internal tree functions
9182  */
9183
9184
9185 static void
9186 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
9187                                      GtkRBTree         *tree,
9188                                      GtkTreeViewColumn *column,
9189                                      gint              *x1,
9190                                      gint              *x2)
9191 {
9192   GtkTreeViewColumn *tmp_column = NULL;
9193   gint total_width;
9194   GList *list;
9195   gboolean rtl;
9196
9197   if (x1)
9198     *x1 = 0;
9199
9200   if (x2)
9201     *x2 = 0;
9202
9203   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9204
9205   total_width = 0;
9206   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9207        list;
9208        list = (rtl ? list->prev : list->next))
9209     {
9210       tmp_column = list->data;
9211
9212       if (tmp_column == column)
9213         break;
9214
9215       if (gtk_tree_view_column_get_visible (tmp_column))
9216         total_width += gtk_tree_view_column_get_width (tmp_column);
9217     }
9218
9219   if (tmp_column != column)
9220     {
9221       g_warning (G_STRLOC": passed-in column isn't in the tree");
9222       return;
9223     }
9224
9225   if (x1)
9226     *x1 = total_width;
9227
9228   if (x2)
9229     {
9230       if (gtk_tree_view_column_get_visible (column))
9231         *x2 = total_width + gtk_tree_view_column_get_width (column);
9232       else
9233         *x2 = total_width; /* width of 0 */
9234     }
9235 }
9236
9237 static void
9238 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
9239                                 GtkRBTree   *tree,
9240                                 gint        *x1,
9241                                 gint        *x2)
9242 {
9243   gint x_offset = 0;
9244   GList *list;
9245   GtkTreeViewColumn *tmp_column = NULL;
9246   gint total_width;
9247   gboolean indent_expanders;
9248   gboolean rtl;
9249
9250   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9251
9252   total_width = 0;
9253   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9254        list;
9255        list = (rtl ? list->prev : list->next))
9256     {
9257       tmp_column = list->data;
9258
9259       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
9260         {
9261           if (rtl)
9262             x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - tree_view->priv->expander_size;
9263           else
9264             x_offset = total_width;
9265           break;
9266         }
9267
9268       if (gtk_tree_view_column_get_visible (tmp_column))
9269         total_width += gtk_tree_view_column_get_width (tmp_column);
9270     }
9271
9272   gtk_widget_style_get (GTK_WIDGET (tree_view),
9273                         "indent-expanders", &indent_expanders,
9274                         NULL);
9275
9276   if (indent_expanders)
9277     {
9278       if (rtl)
9279         x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
9280       else
9281         x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
9282     }
9283
9284   *x1 = x_offset;
9285
9286   if (tmp_column &&
9287       gtk_tree_view_column_get_visible (tmp_column))
9288     /* +1 because x2 isn't included in the range. */
9289     *x2 = *x1 + tree_view->priv->expander_size + 1;
9290   else
9291     *x2 = *x1;
9292 }
9293
9294 static void
9295 gtk_tree_view_build_tree (GtkTreeView *tree_view,
9296                           GtkRBTree   *tree,
9297                           GtkTreeIter *iter,
9298                           gint         depth,
9299                           gboolean     recurse)
9300 {
9301   GtkRBNode *temp = NULL;
9302   GtkTreePath *path = NULL;
9303
9304   do
9305     {
9306       gtk_tree_model_ref_node (tree_view->priv->model, iter);
9307       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
9308
9309       if (tree_view->priv->fixed_height > 0)
9310         {
9311           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
9312             {
9313               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
9314               _gtk_rbtree_node_mark_valid (tree, temp);
9315             }
9316         }
9317
9318       if (tree_view->priv->is_list)
9319         continue;
9320
9321       if (recurse)
9322         {
9323           GtkTreeIter child;
9324
9325           if (!path)
9326             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
9327           else
9328             gtk_tree_path_next (path);
9329
9330           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
9331             {
9332               gboolean expand;
9333
9334               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
9335
9336               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
9337                   && !expand)
9338                 {
9339                   temp->children = _gtk_rbtree_new ();
9340                   temp->children->parent_tree = tree;
9341                   temp->children->parent_node = temp;
9342                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
9343                 }
9344             }
9345         }
9346
9347       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
9348         {
9349           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
9350             temp->flags ^= GTK_RBNODE_IS_PARENT;
9351         }
9352     }
9353   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
9354
9355   if (path)
9356     gtk_tree_path_free (path);
9357 }
9358
9359 /* Make sure the node is visible vertically */
9360 static void
9361 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
9362                                   GtkRBTree   *tree,
9363                                   GtkRBNode   *node)
9364 {
9365   gint node_dy, height;
9366   GtkTreePath *path = NULL;
9367
9368   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9369     return;
9370
9371   /* just return if the node is visible, avoiding a costly expose */
9372   node_dy = _gtk_rbtree_node_find_offset (tree, node);
9373   height = gtk_tree_view_get_row_height (tree_view, node);
9374   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
9375       && node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment)
9376       && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
9377                               + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
9378     return;
9379
9380   path = _gtk_tree_path_new_from_rbtree (tree, node);
9381   if (path)
9382     {
9383       /* We process updates because we want to clear old selected items when we scroll.
9384        * if this is removed, we get a "selection streak" at the bottom. */
9385       gtk_tree_view_bin_process_updates (tree_view);
9386
9387       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
9388       gtk_tree_path_free (path);
9389     }
9390 }
9391
9392 static void
9393 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
9394                                     GtkTreeViewColumn *column,
9395                                     gboolean           focus_to_cell)
9396 {
9397   GtkAllocation allocation;
9398   gint x, width;
9399
9400   if (column == NULL)
9401     return;
9402
9403   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
9404   x = allocation.x;
9405   width = allocation.width;
9406
9407   if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9408     {
9409       /* The column is larger than the horizontal page size.  If the
9410        * column has cells which can be focussed individually, then we make
9411        * sure the cell which gets focus is fully visible (if even the
9412        * focus cell is bigger than the page size, we make sure the
9413        * left-hand side of the cell is visible).
9414        *
9415        * If the column does not have an activatable cell, we
9416        * make sure the left-hand side of the column is visible.
9417        */
9418
9419       if (focus_to_cell && gtk_tree_view_has_can_focus_cell (tree_view))
9420         {
9421           GtkCellArea *cell_area;
9422           GtkCellRenderer *focus_cell;
9423
9424           cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
9425           focus_cell = gtk_cell_area_get_focus_cell (cell_area);
9426
9427           if (gtk_tree_view_column_cell_get_position (column, focus_cell,
9428                                                       &x, &width))
9429             {
9430               if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9431                 {
9432                   if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment) < x + width)
9433                     gtk_adjustment_set_value (tree_view->priv->hadjustment,
9434                                               x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9435                   else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9436                     gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9437                 }
9438             }
9439         }
9440
9441       gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9442     }
9443   else
9444     {
9445       if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
9446           gtk_adjustment_set_value (tree_view->priv->hadjustment,
9447                                     x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9448       else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9449         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9450   }
9451 }
9452
9453 /* This function could be more efficient.  I'll optimize it if profiling seems
9454  * to imply that it is important */
9455 GtkTreePath *
9456 _gtk_tree_path_new_from_rbtree (GtkRBTree   *tree,
9457                                 GtkRBNode   *node)
9458 {
9459   GtkTreePath *path;
9460   GtkRBTree *tmp_tree;
9461   GtkRBNode *tmp_node, *last;
9462   gint count;
9463
9464   path = gtk_tree_path_new ();
9465
9466   g_return_val_if_fail (node != NULL, path);
9467
9468   count = 1 + node->left->count;
9469
9470   last = node;
9471   tmp_node = node->parent;
9472   tmp_tree = tree;
9473   while (tmp_tree)
9474     {
9475       while (!_gtk_rbtree_is_nil (tmp_node))
9476         {
9477           if (tmp_node->right == last)
9478             count += 1 + tmp_node->left->count;
9479           last = tmp_node;
9480           tmp_node = tmp_node->parent;
9481         }
9482       gtk_tree_path_prepend_index (path, count - 1);
9483       last = tmp_tree->parent_node;
9484       tmp_tree = tmp_tree->parent_tree;
9485       if (last)
9486         {
9487           count = 1 + last->left->count;
9488           tmp_node = last->parent;
9489         }
9490     }
9491   return path;
9492 }
9493
9494 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
9495  * invalid (ie. points to a node that's not in the tree), *tree and *node are
9496  * both set to NULL.
9497  */
9498 gboolean
9499 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
9500                           GtkTreePath  *path,
9501                           GtkRBTree   **tree,
9502                           GtkRBNode   **node)
9503 {
9504   GtkRBNode *tmpnode = NULL;
9505   GtkRBTree *tmptree = tree_view->priv->tree;
9506   gint *indices = gtk_tree_path_get_indices (path);
9507   gint depth = gtk_tree_path_get_depth (path);
9508   gint i = 0;
9509
9510   *node = NULL;
9511   *tree = NULL;
9512
9513   if (depth == 0 || tmptree == NULL)
9514     return FALSE;
9515   do
9516     {
9517       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
9518       ++i;
9519       if (tmpnode == NULL)
9520         {
9521           *tree = NULL;
9522           *node = NULL;
9523           return FALSE;
9524         }
9525       if (i >= depth)
9526         {
9527           *tree = tmptree;
9528           *node = tmpnode;
9529           return FALSE;
9530         }
9531       *tree = tmptree;
9532       *node = tmpnode;
9533       tmptree = tmpnode->children;
9534       if (tmptree == NULL)
9535         return TRUE;
9536     }
9537   while (1);
9538 }
9539
9540 static gboolean
9541 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9542                                   GtkTreeViewColumn *column)
9543 {
9544   GList *list;
9545
9546   if (tree_view->priv->is_list)
9547     return FALSE;
9548
9549   if (tree_view->priv->expander_column != NULL)
9550     {
9551       if (tree_view->priv->expander_column == column)
9552         return TRUE;
9553       return FALSE;
9554     }
9555   else
9556     {
9557       for (list = tree_view->priv->columns;
9558            list;
9559            list = list->next)
9560         if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
9561           break;
9562       if (list && list->data == column)
9563         return TRUE;
9564     }
9565   return FALSE;
9566 }
9567
9568 static inline gboolean
9569 gtk_tree_view_draw_expanders (GtkTreeView *tree_view)
9570 {
9571   if (!tree_view->priv->is_list && tree_view->priv->show_expanders)
9572     return TRUE;
9573   /* else */
9574   return FALSE;
9575 }
9576
9577 static void
9578 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9579                                 guint           keyval,
9580                                 guint           modmask,
9581                                 gboolean        add_shifted_binding,
9582                                 GtkMovementStep step,
9583                                 gint            count)
9584 {
9585
9586   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9587                                 "move-cursor", 2,
9588                                 G_TYPE_ENUM, step,
9589                                 G_TYPE_INT, count);
9590
9591   if (add_shifted_binding)
9592     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9593                                   "move-cursor", 2,
9594                                   G_TYPE_ENUM, step,
9595                                   G_TYPE_INT, count);
9596
9597   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9598    return;
9599
9600   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9601                                 "move-cursor", 2,
9602                                 G_TYPE_ENUM, step,
9603                                 G_TYPE_INT, count);
9604
9605   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9606                                 "move-cursor", 2,
9607                                 G_TYPE_ENUM, step,
9608                                 G_TYPE_INT, count);
9609 }
9610
9611 static gint
9612 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9613                                  GtkTreeIter  *iter,
9614                                  GtkRBTree    *tree,
9615                                  GtkRBNode    *node)
9616 {
9617   gint retval = FALSE;
9618   do
9619     {
9620       g_return_val_if_fail (node != NULL, FALSE);
9621
9622       if (node->children)
9623         {
9624           GtkTreeIter child;
9625           GtkRBTree *new_tree;
9626           GtkRBNode *new_node;
9627
9628           new_tree = node->children;
9629           new_node = _gtk_rbtree_first (new_tree);
9630
9631           if (!gtk_tree_model_iter_children (model, &child, iter))
9632             return FALSE;
9633
9634           retval = gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node) | retval;
9635         }
9636
9637       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9638         retval = TRUE;
9639       gtk_tree_model_unref_node (model, iter);
9640       node = _gtk_rbtree_next (tree, node);
9641     }
9642   while (gtk_tree_model_iter_next (model, iter));
9643
9644   return retval;
9645 }
9646
9647 static gint
9648 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9649                                               GtkRBTree   *tree)
9650 {
9651   GtkTreeIter iter;
9652   GtkTreePath *path;
9653   GtkRBNode *node;
9654   gint retval;
9655
9656   if (!tree)
9657     return FALSE;
9658
9659   node = _gtk_rbtree_first (tree);
9660
9661   g_return_val_if_fail (node != NULL, FALSE);
9662   path = _gtk_tree_path_new_from_rbtree (tree, node);
9663   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9664                            &iter, path);
9665   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9666   gtk_tree_path_free (path);
9667
9668   return retval;
9669 }
9670
9671 static void
9672 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9673                                     GtkTreeViewColumn *column)
9674 {
9675   GtkTreeViewColumn *left_column;
9676   GtkTreeViewColumn *cur_column = NULL;
9677   GtkTreeViewColumnReorder *reorder;
9678   gboolean rtl;
9679   GList *tmp_list;
9680   gint left;
9681
9682   /* We want to precalculate the motion list such that we know what column slots
9683    * are available.
9684    */
9685   left_column = NULL;
9686   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9687
9688   /* First, identify all possible drop spots */
9689   if (rtl)
9690     tmp_list = g_list_last (tree_view->priv->columns);
9691   else
9692     tmp_list = g_list_first (tree_view->priv->columns);
9693
9694   while (tmp_list)
9695     {
9696       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9697       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9698
9699       if (gtk_tree_view_column_get_visible (cur_column) == FALSE)
9700         continue;
9701
9702       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9703       if (left_column != column && cur_column != column &&
9704           tree_view->priv->column_drop_func &&
9705           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9706         {
9707           left_column = cur_column;
9708           continue;
9709         }
9710       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9711       reorder->left_column = left_column;
9712       left_column = reorder->right_column = cur_column;
9713
9714       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9715     }
9716
9717   /* Add the last one */
9718   if (tree_view->priv->column_drop_func == NULL ||
9719       ((left_column != column) &&
9720        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9721     {
9722       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9723       reorder->left_column = left_column;
9724       reorder->right_column = NULL;
9725       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9726     }
9727
9728   /* We quickly check to see if it even makes sense to reorder columns. */
9729   /* If there is nothing that can be moved, then we return */
9730
9731   if (tree_view->priv->column_drag_info == NULL)
9732     return;
9733
9734   /* We know there are always 2 slots possbile, as you can always return column. */
9735   /* If that's all there is, return */
9736   if (tree_view->priv->column_drag_info->next == NULL ||
9737       (tree_view->priv->column_drag_info->next->next == NULL &&
9738        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9739        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9740     {
9741       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9742         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9743       g_list_free (tree_view->priv->column_drag_info);
9744       tree_view->priv->column_drag_info = NULL;
9745       return;
9746     }
9747   /* We fill in the ranges for the columns, now that we've isolated them */
9748   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9749
9750   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9751     {
9752       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9753
9754       reorder->left_align = left;
9755       if (tmp_list->next != NULL)
9756         {
9757           GtkAllocation right_allocation, left_allocation;
9758           GtkWidget    *left_button, *right_button;
9759
9760           g_assert (tmp_list->next->data);
9761
9762           right_button = gtk_tree_view_column_get_button (reorder->right_column);
9763           left_button  = gtk_tree_view_column_get_button
9764             (((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column);
9765
9766           gtk_widget_get_allocation (right_button, &right_allocation);
9767           gtk_widget_get_allocation (left_button, &left_allocation);
9768           left = reorder->right_align = (right_allocation.x + right_allocation.width + left_allocation.x) / 2;
9769         }
9770       else
9771         {
9772           reorder->right_align = gdk_window_get_width (tree_view->priv->header_window)
9773                                  + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9774         }
9775     }
9776 }
9777
9778 void
9779 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9780                                   GtkTreeViewColumn *column,
9781                                   GdkDevice         *device)
9782 {
9783   GdkEvent *send_event;
9784   GtkAllocation allocation;
9785   GtkAllocation button_allocation;
9786   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9787   GtkWidget *button;
9788   GdkDevice *pointer, *keyboard;
9789
9790   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9791   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9792
9793   gtk_tree_view_set_column_drag_info (tree_view, column);
9794
9795   if (tree_view->priv->column_drag_info == NULL)
9796     return;
9797
9798   button = gtk_tree_view_column_get_button (column);
9799
9800   if (tree_view->priv->drag_window == NULL)
9801     {
9802       GdkWindowAttr attributes;
9803       guint attributes_mask;
9804
9805       gtk_widget_get_allocation (button, &button_allocation);
9806
9807       attributes.window_type = GDK_WINDOW_CHILD;
9808       attributes.wclass = GDK_INPUT_OUTPUT;
9809       attributes.x = button_allocation.x;
9810       attributes.y = 0;
9811       attributes.width = button_allocation.width;
9812       attributes.height = button_allocation.height;
9813       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9814       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9815       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
9816
9817       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
9818                                                      &attributes,
9819                                                      attributes_mask);
9820       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
9821     }
9822
9823   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
9824     {
9825       keyboard = device;
9826       pointer = gdk_device_get_associated_device (device);
9827     }
9828   else
9829     {
9830       pointer = device;
9831       keyboard = gdk_device_get_associated_device (device);
9832     }
9833
9834   gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
9835   gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);
9836
9837   gtk_grab_remove (button);
9838
9839   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9840   send_event->crossing.send_event = TRUE;
9841   send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (button)));
9842   send_event->crossing.subwindow = NULL;
9843   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9844   send_event->crossing.time = GDK_CURRENT_TIME;
9845   gdk_event_set_device (send_event, device);
9846
9847   gtk_propagate_event (button, send_event);
9848   gdk_event_free (send_event);
9849
9850   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9851   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9852   send_event->button.send_event = TRUE;
9853   send_event->button.time = GDK_CURRENT_TIME;
9854   send_event->button.x = -1;
9855   send_event->button.y = -1;
9856   send_event->button.axes = NULL;
9857   send_event->button.state = 0;
9858   send_event->button.button = GDK_BUTTON_PRIMARY;
9859   send_event->button.x_root = 0;
9860   send_event->button.y_root = 0;
9861   gdk_event_set_device (send_event, device);
9862
9863   gtk_propagate_event (button, send_event);
9864   gdk_event_free (send_event);
9865
9866   /* Kids, don't try this at home */
9867   g_object_ref (button);
9868   gtk_container_remove (GTK_CONTAINER (tree_view), button);
9869   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9870   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
9871   g_object_unref (button);
9872
9873   gtk_widget_get_allocation (button, &button_allocation);
9874   tree_view->priv->drag_column_x = button_allocation.x;
9875   allocation = button_allocation;
9876   allocation.x = 0;
9877   gtk_widget_size_allocate (button, &allocation);
9878   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9879
9880   tree_view->priv->drag_column = column;
9881   gdk_window_show (tree_view->priv->drag_window);
9882
9883   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9884   while (gtk_events_pending ())
9885     gtk_main_iteration ();
9886
9887   tree_view->priv->in_column_drag = TRUE;
9888
9889   gdk_device_grab (pointer,
9890                    tree_view->priv->drag_window,
9891                    GDK_OWNERSHIP_NONE,
9892                    FALSE,
9893                    GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9894                    NULL,
9895                    GDK_CURRENT_TIME);
9896   gdk_device_grab (keyboard,
9897                    tree_view->priv->drag_window,
9898                    GDK_OWNERSHIP_NONE,
9899                    FALSE,
9900                    GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
9901                    NULL,
9902                    GDK_CURRENT_TIME);
9903 }
9904
9905 static void
9906 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9907                                 GtkRBTree          *tree,
9908                                 GtkRBNode          *node)
9909 {
9910   GtkAllocation allocation;
9911   GdkRectangle rect;
9912
9913   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9914     return;
9915
9916   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9917   rect.x = 0;
9918   rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, allocation.width));
9919
9920   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9921   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9922
9923   gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9924 }
9925
9926 void
9927 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9928                                 GtkRBTree          *tree,
9929                                 GtkRBNode          *node,
9930                                 const GdkRectangle *clip_rect)
9931 {
9932   GtkAllocation allocation;
9933   GdkRectangle rect;
9934
9935   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9936     return;
9937
9938   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9939   rect.x = 0;
9940   rect.width = MAX (tree_view->priv->width, allocation.width);
9941
9942   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9943   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9944
9945   if (clip_rect)
9946     {
9947       GdkRectangle new_rect;
9948
9949       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9950
9951       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9952     }
9953   else
9954     {
9955       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9956     }
9957 }
9958
9959 static inline gint
9960 gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view)
9961 {
9962   if (tree_view->priv->headers_visible)
9963     return tree_view->priv->header_height;
9964   /* else */
9965   return 0;
9966 }
9967
9968 gint
9969 _gtk_tree_view_get_header_height (GtkTreeView *tree_view)
9970 {
9971   return tree_view->priv->header_height;
9972 }
9973
9974 void
9975 _gtk_tree_view_get_row_separator_func (GtkTreeView                 *tree_view,
9976                                        GtkTreeViewRowSeparatorFunc *func,
9977                                        gpointer                    *data)
9978 {
9979   *func = tree_view->priv->row_separator_func;
9980   *data = tree_view->priv->row_separator_data;
9981 }
9982
9983 GtkTreePath *
9984 _gtk_tree_view_get_anchor_path (GtkTreeView *tree_view)
9985 {
9986   if (tree_view->priv->anchor)
9987     return gtk_tree_row_reference_get_path (tree_view->priv->anchor);
9988
9989   return NULL;
9990 }
9991
9992 void
9993 _gtk_tree_view_set_anchor_path (GtkTreeView *tree_view,
9994                                 GtkTreePath *anchor_path)
9995 {
9996   if (tree_view->priv->anchor)
9997     {
9998       gtk_tree_row_reference_free (tree_view->priv->anchor);
9999       tree_view->priv->anchor = NULL;
10000     }
10001
10002   if (anchor_path && tree_view->priv->model)
10003     tree_view->priv->anchor =
10004       gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
10005                                         tree_view->priv->model, anchor_path);
10006 }
10007
10008 GtkRBTree *
10009 _gtk_tree_view_get_rbtree (GtkTreeView *tree_view)
10010 {
10011   return tree_view->priv->tree;
10012 }
10013
10014 gboolean
10015 _gtk_tree_view_get_cursor_node (GtkTreeView  *tree_view,
10016                                 GtkRBTree   **tree,
10017                                 GtkRBNode   **node)
10018 {
10019   GtkTreeViewPrivate *priv;
10020
10021   priv = tree_view->priv;
10022
10023   if (priv->cursor_node == NULL)
10024     return FALSE;
10025
10026   *tree = priv->cursor_tree;
10027   *node = priv->cursor_node;
10028
10029   return TRUE;
10030 }
10031
10032 GdkWindow *
10033 _gtk_tree_view_get_header_window (GtkTreeView *tree_view)
10034 {
10035   return tree_view->priv->header_window;
10036 }
10037
10038 GtkTreeViewColumn *
10039 _gtk_tree_view_get_focus_column (GtkTreeView *tree_view)
10040 {
10041   return tree_view->priv->focus_column;
10042 }
10043
10044 void
10045 _gtk_tree_view_set_focus_column (GtkTreeView       *tree_view,
10046                                  GtkTreeViewColumn *column)
10047 {
10048   GtkTreeViewColumn *old_column = tree_view->priv->focus_column;
10049
10050   if (old_column == column)
10051     return;
10052
10053   tree_view->priv->focus_column = column;
10054
10055   _gtk_tree_view_accessible_update_focus_column (tree_view,
10056                                                  old_column,
10057                                                  column);
10058 }
10059
10060
10061 static void
10062 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
10063                                GtkTreePath        *path,
10064                                const GdkRectangle *clip_rect)
10065 {
10066   GtkRBTree *tree = NULL;
10067   GtkRBNode *node = NULL;
10068
10069   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
10070
10071   if (tree)
10072     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
10073 }
10074
10075 /* x and y are the mouse position
10076  */
10077 static void
10078 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
10079                           cairo_t     *cr,
10080                           GtkRBTree   *tree,
10081                           GtkRBNode   *node)
10082 {
10083   GdkRectangle area;
10084   GtkStateFlags state = 0;
10085   GtkStyleContext *context;
10086   GtkWidget *widget;
10087   gint x_offset = 0;
10088   gint x2;
10089   gint vertical_separator;
10090   gint expander_size;
10091   GtkCellRendererState flags = 0;
10092
10093   widget = GTK_WIDGET (tree_view);
10094   context = gtk_widget_get_style_context (widget);
10095
10096   gtk_widget_style_get (widget,
10097                         "vertical-separator", &vertical_separator,
10098                         NULL);
10099   expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
10100
10101   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
10102     return;
10103
10104   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
10105
10106   area.x = x_offset;
10107   area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
10108                                                  vertical_separator);
10109   area.width = expander_size;
10110   area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
10111                                                     vertical_separator);
10112
10113   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
10114     flags |= GTK_CELL_RENDERER_SELECTED;
10115
10116   if (node == tree_view->priv->prelight_node &&
10117       tree_view->priv->arrow_prelit)
10118     flags |= GTK_CELL_RENDERER_PRELIT;
10119
10120   state = gtk_cell_renderer_get_state (NULL, widget, flags);
10121
10122   if (node->children != NULL)
10123     state |= GTK_STATE_FLAG_ACTIVE;
10124   else
10125     state &= ~(GTK_STATE_FLAG_ACTIVE);
10126
10127   gtk_style_context_save (context);
10128
10129   gtk_style_context_set_state (context, state);
10130   gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
10131
10132   gtk_style_context_push_animatable_region (context, node);
10133
10134   gtk_render_expander (context, cr,
10135                        area.x, area.y,
10136                        area.width, area.height);
10137
10138   gtk_style_context_pop_animatable_region (context);
10139   gtk_style_context_restore (context);
10140 }
10141
10142 static void
10143 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
10144
10145 {
10146   GtkTreePath *cursor_path;
10147
10148   if ((tree_view->priv->tree == NULL) ||
10149       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
10150     return;
10151
10152   cursor_path = NULL;
10153   if (tree_view->priv->cursor_node)
10154     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10155                                                   tree_view->priv->cursor_node);
10156
10157   if (cursor_path == NULL)
10158     {
10159       /* Consult the selection before defaulting to the
10160        * first focusable element
10161        */
10162       GList *selected_rows;
10163       GtkTreeModel *model;
10164       GtkTreeSelection *selection;
10165
10166       selection = gtk_tree_view_get_selection (tree_view);
10167       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
10168
10169       if (selected_rows)
10170         {
10171           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
10172           g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free);
10173         }
10174       else
10175         {
10176           cursor_path = gtk_tree_path_new_first ();
10177           search_first_focusable_path (tree_view, &cursor_path,
10178                                        TRUE, NULL, NULL);
10179         }
10180
10181       if (cursor_path)
10182         {
10183           if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
10184             gtk_tree_view_real_set_cursor (tree_view, cursor_path, 0);
10185           else
10186             gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10187         }
10188     }
10189
10190   if (cursor_path)
10191     {
10192       tree_view->priv->draw_keyfocus = TRUE;
10193
10194       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10195       gtk_tree_path_free (cursor_path);
10196
10197       if (tree_view->priv->focus_column == NULL)
10198         {
10199           GList *list;
10200           for (list = tree_view->priv->columns; list; list = list->next)
10201             {
10202               if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
10203                 {
10204                   GtkCellArea *cell_area;
10205
10206                   _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
10207
10208                   /* This happens when the treeview initially grabs focus and there
10209                    * is no column in focus, here we explicitly focus into the first cell */
10210                   cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10211                   if (!gtk_cell_area_get_focus_cell (cell_area))
10212                     {
10213                       gboolean rtl;
10214
10215                       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10216                       gtk_cell_area_focus (cell_area,
10217                                            rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
10218                     }
10219
10220                   break;
10221                 }
10222             }
10223         }
10224     }
10225 }
10226
10227 static void
10228 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
10229                                    gint         count)
10230 {
10231   gint selection_count;
10232   GtkRBTree *new_cursor_tree = NULL;
10233   GtkRBNode *new_cursor_node = NULL;
10234   GtkTreePath *cursor_path = NULL;
10235   gboolean grab_focus = TRUE;
10236   gboolean selectable;
10237   GtkDirectionType direction;
10238   GtkCellArea *cell_area = NULL;
10239   GtkCellRenderer *last_focus_cell = NULL;
10240   GtkTreeIter iter;
10241
10242   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10243     return;
10244
10245   if (tree_view->priv->cursor_node == NULL)
10246     return;
10247
10248   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10249                                                 tree_view->priv->cursor_node);
10250
10251   direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
10252
10253   if (tree_view->priv->focus_column)
10254     cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10255
10256   /* If focus stays in the area for this row, then just return for this round */
10257   if (cell_area && (count == -1 || count == 1) &&
10258       gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path))
10259     {
10260       gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
10261                                                tree_view->priv->model,
10262                                                &iter,
10263                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10264                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10265
10266       /* Save the last cell that had focus, if we hit the end of the view we'll give
10267        * focus back to it. */
10268       last_focus_cell = gtk_cell_area_get_focus_cell (cell_area);
10269
10270       /* If focus stays in the area, no need to change the cursor row */
10271       if (gtk_cell_area_focus (cell_area, direction))
10272         return;
10273     }
10274
10275   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
10276   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
10277                                                       tree_view->priv->cursor_node,
10278                                                       cursor_path);
10279
10280   if (selection_count == 0
10281       && gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE
10282       && !tree_view->priv->modify_selection_pressed
10283       && selectable)
10284     {
10285       /* Don't move the cursor, but just select the current node */
10286       new_cursor_tree = tree_view->priv->cursor_tree;
10287       new_cursor_node = tree_view->priv->cursor_node;
10288     }
10289   else
10290     {
10291       if (count == -1)
10292         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10293                                &new_cursor_tree, &new_cursor_node);
10294       else
10295         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10296                                &new_cursor_tree, &new_cursor_node);
10297     }
10298
10299   gtk_tree_path_free (cursor_path);
10300
10301   if (new_cursor_node)
10302     {
10303       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10304
10305       search_first_focusable_path (tree_view, &cursor_path,
10306                                    (count != -1),
10307                                    &new_cursor_tree,
10308                                    &new_cursor_node);
10309
10310       if (cursor_path)
10311         gtk_tree_path_free (cursor_path);
10312     }
10313
10314   /*
10315    * If the list has only one item and multi-selection is set then select
10316    * the row (if not yet selected).
10317    */
10318   if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE &&
10319       new_cursor_node == NULL)
10320     {
10321       if (count == -1)
10322         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10323                                &new_cursor_tree, &new_cursor_node);
10324       else
10325         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10326                                &new_cursor_tree, &new_cursor_node);
10327
10328       if (new_cursor_node == NULL
10329           && !GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
10330         {
10331           new_cursor_node = tree_view->priv->cursor_node;
10332           new_cursor_tree = tree_view->priv->cursor_tree;
10333         }
10334       else
10335         {
10336           new_cursor_tree = NULL;
10337           new_cursor_node = NULL;
10338         }
10339     }
10340
10341   if (new_cursor_node)
10342     {
10343       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10344       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10345       gtk_tree_path_free (cursor_path);
10346
10347       /* Give focus to the area in the new row */
10348       if (cell_area)
10349         gtk_cell_area_focus (cell_area, direction);
10350     }
10351   else
10352     {
10353       gtk_tree_view_clamp_node_visible (tree_view,
10354                                         tree_view->priv->cursor_tree,
10355                                         tree_view->priv->cursor_node);
10356
10357       if (!tree_view->priv->extend_selection_pressed)
10358         {
10359           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
10360                                           count < 0 ?
10361                                           GTK_DIR_UP : GTK_DIR_DOWN))
10362             {
10363               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10364
10365               if (toplevel)
10366                 gtk_widget_child_focus (toplevel,
10367                                         count < 0 ?
10368                                         GTK_DIR_TAB_BACKWARD :
10369                                         GTK_DIR_TAB_FORWARD);
10370
10371               grab_focus = FALSE;
10372             }
10373         }
10374       else
10375         {
10376           gtk_widget_error_bell (GTK_WIDGET (tree_view));
10377         }
10378
10379       if (cell_area)
10380         gtk_cell_area_set_focus_cell (cell_area, last_focus_cell);
10381     }
10382
10383   if (grab_focus)
10384     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10385 }
10386
10387 static void
10388 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
10389                                         gint         count)
10390 {
10391   GtkTreePath *old_cursor_path = NULL;
10392   GtkTreePath *cursor_path = NULL;
10393   GtkRBTree *start_cursor_tree = NULL;
10394   GtkRBNode *start_cursor_node = NULL;
10395   GtkRBTree *cursor_tree;
10396   GtkRBNode *cursor_node;
10397   gint y;
10398   gint window_y;
10399   gint vertical_separator;
10400
10401   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10402     return;
10403
10404   if (tree_view->priv->cursor_node == NULL)
10405     return;
10406
10407   old_cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10408                                                     tree_view->priv->cursor_node);
10409
10410   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
10411
10412   y = _gtk_rbtree_node_find_offset (tree_view->priv->cursor_tree, tree_view->priv->cursor_node);
10413   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
10414   y += tree_view->priv->cursor_offset;
10415   y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
10416   y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment),  (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
10417
10418   if (y >= tree_view->priv->height)
10419     y = tree_view->priv->height - 1;
10420
10421   tree_view->priv->cursor_offset =
10422     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
10423                              &cursor_tree, &cursor_node);
10424
10425   if (cursor_tree == NULL)
10426     {
10427       /* FIXME: we lost the cursor.  Should we try to get one? */
10428       gtk_tree_path_free (old_cursor_path);
10429       return;
10430     }
10431
10432   if (tree_view->priv->cursor_offset
10433       > gtk_tree_view_get_row_height (tree_view, cursor_node))
10434     {
10435       _gtk_rbtree_next_full (cursor_tree, cursor_node,
10436                              &cursor_tree, &cursor_node);
10437       tree_view->priv->cursor_offset -= gtk_tree_view_get_row_height (tree_view, cursor_node);
10438     }
10439
10440   y -= tree_view->priv->cursor_offset;
10441   cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10442
10443   start_cursor_tree = cursor_tree;
10444   start_cursor_node = cursor_node;
10445
10446   if (! search_first_focusable_path (tree_view, &cursor_path,
10447                                      (count != -1),
10448                                      &cursor_tree, &cursor_node))
10449     {
10450       /* It looks like we reached the end of the view without finding
10451        * a focusable row.  We will step backwards to find the last
10452        * focusable row.
10453        */
10454       cursor_tree = start_cursor_tree;
10455       cursor_node = start_cursor_node;
10456       cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10457
10458       search_first_focusable_path (tree_view, &cursor_path,
10459                                    (count == -1),
10460                                    &cursor_tree, &cursor_node);
10461     }
10462
10463   if (!cursor_path)
10464     goto cleanup;
10465
10466   /* update y */
10467   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10468
10469   gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10470
10471   y -= window_y;
10472   gtk_tree_view_scroll_to_point (tree_view, -1, y);
10473   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10474   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10475
10476   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
10477     gtk_widget_error_bell (GTK_WIDGET (tree_view));
10478
10479   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10480
10481 cleanup:
10482   gtk_tree_path_free (old_cursor_path);
10483   gtk_tree_path_free (cursor_path);
10484 }
10485
10486 static void
10487 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
10488                                       gint         count)
10489 {
10490   GtkTreePath *cursor_path = NULL;
10491   GtkTreeViewColumn *column;
10492   GtkTreeIter iter;
10493   GList *list;
10494   gboolean found_column = FALSE;
10495   gboolean rtl;
10496   GtkDirectionType direction;
10497   GtkCellArea     *cell_area;
10498   GtkCellRenderer *last_focus_cell = NULL;
10499   GtkCellArea     *last_focus_area = NULL;
10500
10501   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10502
10503   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10504     return;
10505
10506   if (tree_view->priv->cursor_node == NULL)
10507     return;
10508
10509   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10510                                                 tree_view->priv->cursor_node);
10511
10512   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
10513     {
10514       gtk_tree_path_free (cursor_path);
10515       return;
10516     }
10517   gtk_tree_path_free (cursor_path);
10518
10519   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
10520   if (tree_view->priv->focus_column)
10521     {
10522       /* Save the cell/area we are moving focus from, if moving the cursor
10523        * by one step hits the end we'll set focus back here */
10524       last_focus_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10525       last_focus_cell = gtk_cell_area_get_focus_cell (last_focus_area);
10526
10527       for (; list; list = (rtl ? list->prev : list->next))
10528         {
10529           if (list->data == tree_view->priv->focus_column)
10530             break;
10531         }
10532     }
10533
10534   direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
10535
10536   while (list)
10537     {
10538       column = list->data;
10539       if (gtk_tree_view_column_get_visible (column) == FALSE)
10540         goto loop_end;
10541
10542       gtk_tree_view_column_cell_set_cell_data (column,
10543                                                tree_view->priv->model,
10544                                                &iter,
10545                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10546                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10547
10548       cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
10549       if (gtk_cell_area_focus (cell_area, direction))
10550         {
10551           _gtk_tree_view_set_focus_column (tree_view, column);
10552           found_column = TRUE;
10553           break;
10554         }
10555
10556     loop_end:
10557       if (count == 1)
10558         list = rtl ? list->prev : list->next;
10559       else
10560         list = rtl ? list->next : list->prev;
10561     }
10562
10563   if (found_column)
10564     {
10565       if (!gtk_tree_view_has_can_focus_cell (tree_view))
10566         _gtk_tree_view_queue_draw_node (tree_view,
10567                                         tree_view->priv->cursor_tree,
10568                                         tree_view->priv->cursor_node,
10569                                         NULL);
10570       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
10571       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10572     }
10573   else
10574     {
10575       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10576
10577       if (last_focus_area)
10578         gtk_cell_area_set_focus_cell (last_focus_area, last_focus_cell);
10579     }
10580
10581   gtk_tree_view_clamp_column_visible (tree_view,
10582                                       tree_view->priv->focus_column, TRUE);
10583 }
10584
10585 static void
10586 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
10587                                      gint         count)
10588 {
10589   GtkRBTree *cursor_tree;
10590   GtkRBNode *cursor_node;
10591   GtkTreePath *path;
10592   GtkTreePath *old_path;
10593
10594   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10595     return;
10596
10597   g_return_if_fail (tree_view->priv->tree != NULL);
10598
10599   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
10600
10601   cursor_tree = tree_view->priv->tree;
10602
10603   if (count == -1)
10604     {
10605       cursor_node = _gtk_rbtree_first (cursor_tree);
10606
10607       /* Now go forward to find the first focusable row. */
10608       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10609       search_first_focusable_path (tree_view, &path,
10610                                    TRUE, &cursor_tree, &cursor_node);
10611     }
10612   else
10613     {
10614       cursor_node = cursor_tree->root;
10615
10616       do
10617         {
10618           while (cursor_node && !_gtk_rbtree_is_nil (cursor_node->right))
10619             cursor_node = cursor_node->right;
10620           if (cursor_node->children == NULL)
10621             break;
10622
10623           cursor_tree = cursor_node->children;
10624           cursor_node = cursor_tree->root;
10625         }
10626       while (1);
10627
10628       /* Now go backwards to find last focusable row. */
10629       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10630       search_first_focusable_path (tree_view, &path,
10631                                    FALSE, &cursor_tree, &cursor_node);
10632     }
10633
10634   if (!path)
10635     goto cleanup;
10636
10637   if (gtk_tree_path_compare (old_path, path))
10638     {
10639       gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
10640       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10641     }
10642   else
10643     {
10644       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10645     }
10646
10647 cleanup:
10648   gtk_tree_path_free (old_path);
10649   gtk_tree_path_free (path);
10650 }
10651
10652 static gboolean
10653 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10654 {
10655   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10656     return FALSE;
10657
10658   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10659     return FALSE;
10660
10661   gtk_tree_selection_select_all (tree_view->priv->selection);
10662
10663   return TRUE;
10664 }
10665
10666 static gboolean
10667 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
10668 {
10669   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10670     return FALSE;
10671
10672   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10673     return FALSE;
10674
10675   gtk_tree_selection_unselect_all (tree_view->priv->selection);
10676
10677   return TRUE;
10678 }
10679
10680 static gboolean
10681 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10682                                       gboolean     start_editing)
10683 {
10684   GtkRBTree *new_tree = NULL;
10685   GtkRBNode *new_node = NULL;
10686   GtkRBTree *cursor_tree = NULL;
10687   GtkRBNode *cursor_node = NULL;
10688   GtkTreePath *cursor_path = NULL;
10689   GtkTreeSelectMode mode = 0;
10690
10691   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10692     return FALSE;
10693
10694   if (tree_view->priv->cursor_node == NULL)
10695     return FALSE;
10696
10697   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10698                                                 tree_view->priv->cursor_node);
10699
10700   _gtk_tree_view_find_node (tree_view, cursor_path,
10701                             &cursor_tree, &cursor_node);
10702
10703   if (cursor_tree == NULL)
10704     {
10705       gtk_tree_path_free (cursor_path);
10706       return FALSE;
10707     }
10708
10709   if (!tree_view->priv->extend_selection_pressed && start_editing &&
10710       tree_view->priv->focus_column)
10711     {
10712       if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE))
10713         {
10714           gtk_tree_path_free (cursor_path);
10715           return TRUE;
10716         }
10717     }
10718
10719   if (tree_view->priv->modify_selection_pressed)
10720     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10721   if (tree_view->priv->extend_selection_pressed)
10722     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10723
10724   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10725                                             cursor_node,
10726                                             cursor_tree,
10727                                             cursor_path,
10728                                             mode,
10729                                             FALSE);
10730
10731   /* We bail out if the original (tree, node) don't exist anymore after
10732    * handling the selection-changed callback.  We do return TRUE because
10733    * the key press has been handled at this point.
10734    */
10735   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10736
10737   if (cursor_tree != new_tree || cursor_node != new_node)
10738     return FALSE;
10739
10740   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10741
10742   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10743   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10744
10745   if (!tree_view->priv->extend_selection_pressed)
10746     gtk_tree_view_row_activated (tree_view, cursor_path,
10747                                  tree_view->priv->focus_column);
10748
10749   gtk_tree_path_free (cursor_path);
10750
10751   return TRUE;
10752 }
10753
10754 static gboolean
10755 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10756 {
10757   GtkRBTree *new_tree = NULL;
10758   GtkRBNode *new_node = NULL;
10759   GtkTreePath *cursor_path = NULL;
10760
10761   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10762     return FALSE;
10763
10764   if (tree_view->priv->cursor_node == NULL)
10765     return FALSE;
10766
10767   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10768                                                 tree_view->priv->cursor_node);
10769
10770   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10771                                             tree_view->priv->cursor_node,
10772                                             tree_view->priv->cursor_tree,
10773                                             cursor_path,
10774                                             GTK_TREE_SELECT_MODE_TOGGLE,
10775                                             FALSE);
10776
10777   /* We bail out if the original (tree, node) don't exist anymore after
10778    * handling the selection-changed callback.  We do return TRUE because
10779    * the key press has been handled at this point.
10780    */
10781   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10782
10783   if (tree_view->priv->cursor_node != new_node)
10784     return FALSE;
10785
10786   gtk_tree_view_clamp_node_visible (tree_view,
10787                                     tree_view->priv->cursor_tree,
10788                                     tree_view->priv->cursor_node);
10789
10790   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10791   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10792   gtk_tree_path_free (cursor_path);
10793
10794   return TRUE;
10795 }
10796
10797 static gboolean
10798 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10799                                                gboolean     logical,
10800                                                gboolean     expand,
10801                                                gboolean     open_all)
10802 {
10803   GtkTreePath *cursor_path = NULL;
10804
10805   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10806     return FALSE;
10807
10808   if (tree_view->priv->cursor_node == NULL)
10809     return FALSE;
10810
10811   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10812                                                 tree_view->priv->cursor_node);
10813
10814   /* Don't handle the event if we aren't an expander */
10815   if (!GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT))
10816     return FALSE;
10817
10818   if (!logical
10819       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10820     expand = !expand;
10821
10822   if (expand)
10823     gtk_tree_view_real_expand_row (tree_view,
10824                                    cursor_path,
10825                                    tree_view->priv->cursor_tree,
10826                                    tree_view->priv->cursor_node,
10827                                    open_all,
10828                                    TRUE);
10829   else
10830     gtk_tree_view_real_collapse_row (tree_view,
10831                                      cursor_path,
10832                                      tree_view->priv->cursor_tree,
10833                                      tree_view->priv->cursor_node,
10834                                      TRUE);
10835
10836   gtk_tree_path_free (cursor_path);
10837
10838   return TRUE;
10839 }
10840
10841 static gboolean
10842 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10843 {
10844   GtkTreePath *cursor_path = NULL;
10845   GdkModifierType state;
10846
10847   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10848     goto out;
10849
10850   if (tree_view->priv->cursor_node == NULL)
10851     goto out;
10852
10853   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10854                                                 tree_view->priv->cursor_node);
10855
10856   if (tree_view->priv->cursor_tree->parent_node)
10857     {
10858       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10859
10860       gtk_tree_path_up (cursor_path);
10861
10862       if (gtk_get_current_event_state (&state))
10863         {
10864           GdkModifierType modify_mod_mask;
10865
10866           modify_mod_mask =
10867             gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
10868                                           GDK_MODIFIER_INTENT_MODIFY_SELECTION);
10869
10870           if ((state & modify_mod_mask) == modify_mod_mask)
10871             tree_view->priv->modify_selection_pressed = TRUE;
10872         }
10873
10874       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10875       gtk_tree_path_free (cursor_path);
10876
10877       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10878
10879       tree_view->priv->modify_selection_pressed = FALSE;
10880
10881       return TRUE;
10882     }
10883
10884  out:
10885
10886   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10887   return FALSE;
10888 }
10889
10890 static gboolean
10891 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10892 {
10893   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
10894   tree_view->priv->typeselect_flush_timeout = 0;
10895
10896   return FALSE;
10897 }
10898
10899 /* Cut and paste from gtkwindow.c */
10900 static void
10901 send_focus_change (GtkWidget *widget,
10902                    GdkDevice *device,
10903                    gboolean   in)
10904 {
10905   GdkDeviceManager *device_manager;
10906   GList *devices, *d;
10907
10908   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
10909   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
10910   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
10911   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
10912
10913   for (d = devices; d; d = d->next)
10914     {
10915       GdkDevice *dev = d->data;
10916       GdkEvent *fevent;
10917       GdkWindow *window;
10918
10919       if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
10920         continue;
10921
10922       window = gtk_widget_get_window (widget);
10923
10924       /* Skip non-master keyboards that haven't
10925        * selected for events from this window
10926        */
10927       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
10928           !gdk_window_get_device_events (window, dev))
10929         continue;
10930
10931       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10932
10933       fevent->focus_change.type = GDK_FOCUS_CHANGE;
10934       fevent->focus_change.window = g_object_ref (window);
10935       fevent->focus_change.in = in;
10936       gdk_event_set_device (fevent, device);
10937
10938       gtk_widget_send_focus_change (widget, fevent);
10939
10940       gdk_event_free (fevent);
10941     }
10942
10943   g_list_free (devices);
10944 }
10945
10946 static void
10947 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10948 {
10949   GtkWidget *frame, *vbox, *toplevel;
10950   GdkScreen *screen;
10951
10952   if (tree_view->priv->search_custom_entry_set)
10953     return;
10954
10955   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10956   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10957
10958    if (tree_view->priv->search_window != NULL)
10959      {
10960        if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10961          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10962                                       GTK_WINDOW (tree_view->priv->search_window));
10963        else if (gtk_window_has_group (GTK_WINDOW (tree_view->priv->search_window)))
10964          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
10965                                          GTK_WINDOW (tree_view->priv->search_window));
10966
10967        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10968
10969        return;
10970      }
10971
10972   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10973   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10974
10975   if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10976     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10977                                  GTK_WINDOW (tree_view->priv->search_window));
10978
10979   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10980                             GDK_WINDOW_TYPE_HINT_UTILITY);
10981   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10982   g_signal_connect (tree_view->priv->search_window, "delete-event",
10983                     G_CALLBACK (gtk_tree_view_search_delete_event),
10984                     tree_view);
10985   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10986                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10987                     tree_view);
10988   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10989                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10990                     tree_view);
10991   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10992                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10993                     tree_view);
10994
10995   frame = gtk_frame_new (NULL);
10996   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10997   gtk_widget_show (frame);
10998   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10999
11000   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
11001   gtk_widget_show (vbox);
11002   gtk_container_add (GTK_CONTAINER (frame), vbox);
11003   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
11004
11005   /* add entry */
11006   tree_view->priv->search_entry = gtk_entry_new ();
11007   gtk_widget_show (tree_view->priv->search_entry);
11008   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
11009                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
11010                     tree_view);
11011   g_signal_connect (tree_view->priv->search_entry,
11012                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
11013                     tree_view);
11014
11015   g_signal_connect (_gtk_entry_get_im_context (GTK_ENTRY (tree_view->priv->search_entry)),
11016                     "preedit-changed",
11017                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
11018                     tree_view);
11019
11020   gtk_container_add (GTK_CONTAINER (vbox),
11021                      tree_view->priv->search_entry);
11022
11023   gtk_widget_realize (tree_view->priv->search_entry);
11024 }
11025
11026 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
11027  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
11028  */
11029 static gboolean
11030 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
11031                                              GdkDevice   *device,
11032                                              gboolean     keybinding)
11033 {
11034   /* We only start interactive search if we have focus or the columns
11035    * have focus.  If one of our children have focus, we don't want to
11036    * start the search.
11037    */
11038   GList *list;
11039   gboolean found_focus = FALSE;
11040   GtkWidgetClass *entry_parent_class;
11041
11042   if (!tree_view->priv->enable_search && !keybinding)
11043     return FALSE;
11044
11045   if (tree_view->priv->search_custom_entry_set)
11046     return FALSE;
11047
11048   if (tree_view->priv->search_window != NULL &&
11049       gtk_widget_get_visible (tree_view->priv->search_window))
11050     return TRUE;
11051
11052   for (list = tree_view->priv->columns; list; list = list->next)
11053     {
11054       GtkTreeViewColumn *column;
11055       GtkWidget         *button;
11056
11057       column = list->data;
11058       if (!gtk_tree_view_column_get_visible (column))
11059         continue;
11060
11061       button = gtk_tree_view_column_get_button (column);
11062       if (gtk_widget_has_focus (button))
11063         {
11064           found_focus = TRUE;
11065           break;
11066         }
11067     }
11068
11069   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
11070     found_focus = TRUE;
11071
11072   if (!found_focus)
11073     return FALSE;
11074
11075   if (tree_view->priv->search_column < 0)
11076     return FALSE;
11077
11078   gtk_tree_view_ensure_interactive_directory (tree_view);
11079
11080   if (keybinding)
11081     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
11082
11083   /* done, show it */
11084   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
11085   gtk_widget_show (tree_view->priv->search_window);
11086   if (tree_view->priv->search_entry_changed_id == 0)
11087     {
11088       tree_view->priv->search_entry_changed_id =
11089         g_signal_connect (tree_view->priv->search_entry, "changed",
11090                           G_CALLBACK (gtk_tree_view_search_init),
11091                           tree_view);
11092     }
11093
11094   tree_view->priv->typeselect_flush_timeout =
11095     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
11096                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
11097                    tree_view);
11098
11099   /* Grab focus will select all the text.  We don't want that to happen, so we
11100    * call the parent instance and bypass the selection change.  This is probably
11101    * really non-kosher. */
11102   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
11103   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
11104
11105   /* send focus-in event */
11106   send_focus_change (tree_view->priv->search_entry, device, TRUE);
11107
11108   /* search first matching iter */
11109   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
11110
11111   return TRUE;
11112 }
11113
11114 static gboolean
11115 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
11116 {
11117   return gtk_tree_view_real_start_interactive_search (tree_view,
11118                                                       gtk_get_current_event_device (),
11119                                                       TRUE);
11120 }
11121
11122 /* this function returns the new width of the column being resized given
11123  * the column and x position of the cursor; the x cursor position is passed
11124  * in as a pointer and automagicly corrected if it's beyond min/max limits
11125  */
11126 static gint
11127 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
11128                                 gint       i,
11129                                 gint      *x)
11130 {
11131   GtkAllocation allocation;
11132   GtkTreeViewColumn *column;
11133   GtkRequisition button_req;
11134   gint max_width, min_width;
11135   gint width;
11136   gboolean rtl;
11137
11138   /* first translate the x position from widget->window
11139    * to clist->clist_window
11140    */
11141   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
11142   column = g_list_nth (tree_view->priv->columns, i)->data;
11143   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
11144   width = rtl ? (allocation.x + allocation.width - *x) : (*x - allocation.x);
11145
11146   /* Clamp down the value */
11147   min_width = gtk_tree_view_column_get_min_width (column);
11148   if (min_width == -1)
11149     {
11150       gtk_widget_get_preferred_size (gtk_tree_view_column_get_button (column), &button_req, NULL);
11151       width = MAX (button_req.width, width);
11152     }
11153   else
11154     width = MAX (min_width, width);
11155
11156   max_width = gtk_tree_view_column_get_max_width (column);
11157   if (max_width != -1)
11158     width = MIN (width, max_width);
11159
11160   *x = rtl ? (allocation.x + allocation.width - width) : (allocation.x + width);
11161
11162   return width;
11163 }
11164
11165
11166 /* FIXME this adjust_allocation is a big cut-and-paste from
11167  * GtkCList, needs to be some "official" way to do this
11168  * factored out.
11169  */
11170 typedef struct
11171 {
11172   GdkWindow *window;
11173   int dx;
11174   int dy;
11175 } ScrollData;
11176
11177 /* The window to which widget->window is relative */
11178 #define ALLOCATION_WINDOW(widget)               \
11179    (!gtk_widget_get_has_window (widget) ?                   \
11180     gtk_widget_get_window (widget) :                        \
11181     gdk_window_get_parent (gtk_widget_get_window (widget)))
11182
11183 static void
11184 adjust_allocation_recurse (GtkWidget *widget,
11185                            gpointer   data)
11186 {
11187   GtkAllocation allocation;
11188   ScrollData *scroll_data = data;
11189
11190   /* Need to really size allocate instead of just poking
11191    * into widget->allocation if the widget is not realized.
11192    * FIXME someone figure out why this was.
11193    */
11194   gtk_widget_get_allocation (widget, &allocation);
11195   if (!gtk_widget_get_realized (widget))
11196     {
11197       if (gtk_widget_get_visible (widget))
11198         {
11199           GdkRectangle tmp_rectangle = allocation;
11200           tmp_rectangle.x += scroll_data->dx;
11201           tmp_rectangle.y += scroll_data->dy;
11202
11203           gtk_widget_size_allocate (widget, &tmp_rectangle);
11204         }
11205     }
11206   else
11207     {
11208       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
11209         {
11210           allocation.x += scroll_data->dx;
11211           allocation.y += scroll_data->dy;
11212           gtk_widget_set_allocation (widget, &allocation);
11213
11214           if (GTK_IS_CONTAINER (widget))
11215             gtk_container_forall (GTK_CONTAINER (widget),
11216                                   adjust_allocation_recurse,
11217                                   data);
11218         }
11219     }
11220 }
11221
11222 static void
11223 adjust_allocation (GtkWidget *widget,
11224                    int        dx,
11225                    int        dy)
11226 {
11227   ScrollData scroll_data;
11228
11229   if (gtk_widget_get_realized (widget))
11230     scroll_data.window = ALLOCATION_WINDOW (widget);
11231   else
11232     scroll_data.window = NULL;
11233
11234   scroll_data.dx = dx;
11235   scroll_data.dy = dy;
11236
11237   adjust_allocation_recurse (widget, &scroll_data);
11238 }
11239
11240 /* Callbacks */
11241 static void
11242 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
11243                                   GtkTreeView   *tree_view)
11244 {
11245   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11246     {
11247       GtkStyleContext *context;
11248       gint dy;
11249
11250       gdk_window_move (tree_view->priv->bin_window,
11251                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11252                        gtk_tree_view_get_effective_header_height (tree_view));
11253       gdk_window_move (tree_view->priv->header_window,
11254                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11255                        0);
11256       dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11257       if (dy)
11258         {
11259           update_prelight (tree_view,
11260                            tree_view->priv->event_last_x,
11261                            tree_view->priv->event_last_y - dy);
11262
11263           if (tree_view->priv->edited_column)
11264             {
11265               GList *list;
11266               GtkTreeViewChild *child = NULL;
11267               GtkCellEditable *edit_widget;
11268               GtkCellArea *area;
11269
11270               area        = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column));
11271               edit_widget = gtk_cell_area_get_edit_widget (area);
11272               if (GTK_IS_WIDGET (edit_widget))
11273                 {
11274                   adjust_allocation (GTK_WIDGET (edit_widget), 0, dy);
11275
11276                   for (list = tree_view->priv->children; list; list = list->next)
11277                     {
11278                       child = (GtkTreeViewChild *)list->data;
11279                       if (child->widget == GTK_WIDGET (edit_widget))
11280                         {
11281                           child->y += dy;
11282                           break;
11283                         }
11284                     }
11285                 }
11286             }
11287         }
11288       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
11289
11290       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
11291       gtk_style_context_scroll_animations (context, tree_view->priv->bin_window, 0, dy);
11292
11293       if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
11294         {
11295           /* update our dy and top_row */
11296           tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11297
11298           if (!tree_view->priv->in_top_row_to_dy)
11299             gtk_tree_view_dy_to_top_row (tree_view);
11300         }
11301
11302       gdk_window_process_updates (tree_view->priv->header_window, TRUE);
11303       gtk_tree_view_bin_process_updates (tree_view);
11304     }
11305 }
11306
11307 \f
11308
11309 /* Public methods
11310  */
11311
11312 /**
11313  * gtk_tree_view_new:
11314  *
11315  * Creates a new #GtkTreeView widget.
11316  *
11317  * Return value: A newly created #GtkTreeView widget.
11318  **/
11319 GtkWidget *
11320 gtk_tree_view_new (void)
11321 {
11322   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
11323 }
11324
11325 /**
11326  * gtk_tree_view_new_with_model:
11327  * @model: the model.
11328  *
11329  * Creates a new #GtkTreeView widget with the model initialized to @model.
11330  *
11331  * Return value: A newly created #GtkTreeView widget.
11332  **/
11333 GtkWidget *
11334 gtk_tree_view_new_with_model (GtkTreeModel *model)
11335 {
11336   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
11337 }
11338
11339 /* Public Accessors
11340  */
11341
11342 /**
11343  * gtk_tree_view_get_model:
11344  * @tree_view: a #GtkTreeView
11345  *
11346  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
11347  * model is unset.
11348  *
11349  * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
11350  **/
11351 GtkTreeModel *
11352 gtk_tree_view_get_model (GtkTreeView *tree_view)
11353 {
11354   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11355
11356   return tree_view->priv->model;
11357 }
11358
11359 /**
11360  * gtk_tree_view_set_model:
11361  * @tree_view: A #GtkTreeNode.
11362  * @model: (allow-none): The model.
11363  *
11364  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
11365  * set, it will remove it before setting the new model.  If @model is %NULL,
11366  * then it will unset the old model.
11367  **/
11368 void
11369 gtk_tree_view_set_model (GtkTreeView  *tree_view,
11370                          GtkTreeModel *model)
11371 {
11372   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11373   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
11374
11375   if (model == tree_view->priv->model)
11376     return;
11377
11378   if (tree_view->priv->scroll_to_path)
11379     {
11380       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11381       tree_view->priv->scroll_to_path = NULL;
11382     }
11383
11384   if (tree_view->priv->rubber_band_status)
11385     gtk_tree_view_stop_rubber_band (tree_view);
11386
11387   if (tree_view->priv->model)
11388     {
11389       GList *tmplist = tree_view->priv->columns;
11390       GtkStyleContext *context;
11391
11392       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
11393       gtk_tree_view_stop_editing (tree_view, TRUE);
11394
11395       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
11396       gtk_style_context_cancel_animations (context, NULL);
11397
11398       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11399                                             gtk_tree_view_row_changed,
11400                                             tree_view);
11401       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11402                                             gtk_tree_view_row_inserted,
11403                                             tree_view);
11404       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11405                                             gtk_tree_view_row_has_child_toggled,
11406                                             tree_view);
11407       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11408                                             gtk_tree_view_row_deleted,
11409                                             tree_view);
11410       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11411                                             gtk_tree_view_rows_reordered,
11412                                             tree_view);
11413
11414       for (; tmplist; tmplist = tmplist->next)
11415         _gtk_tree_view_column_unset_model (tmplist->data,
11416                                            tree_view->priv->model);
11417
11418       if (tree_view->priv->tree)
11419         gtk_tree_view_free_rbtree (tree_view);
11420
11421       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
11422       tree_view->priv->drag_dest_row = NULL;
11423       gtk_tree_row_reference_free (tree_view->priv->anchor);
11424       tree_view->priv->anchor = NULL;
11425       gtk_tree_row_reference_free (tree_view->priv->top_row);
11426       tree_view->priv->top_row = NULL;
11427       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11428       tree_view->priv->scroll_to_path = NULL;
11429
11430       tree_view->priv->scroll_to_column = NULL;
11431
11432       g_object_unref (tree_view->priv->model);
11433
11434       tree_view->priv->search_column = -1;
11435       tree_view->priv->fixed_height_check = 0;
11436       tree_view->priv->fixed_height = -1;
11437       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
11438       tree_view->priv->last_button_x = -1;
11439       tree_view->priv->last_button_y = -1;
11440     }
11441
11442   tree_view->priv->model = model;
11443
11444   if (tree_view->priv->model)
11445     {
11446       gint i;
11447       GtkTreePath *path;
11448       GtkTreeIter iter;
11449       GtkTreeModelFlags flags;
11450
11451       if (tree_view->priv->search_column == -1)
11452         {
11453           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
11454             {
11455               GType type = gtk_tree_model_get_column_type (model, i);
11456
11457               if (g_value_type_transformable (type, G_TYPE_STRING))
11458                 {
11459                   tree_view->priv->search_column = i;
11460                   break;
11461                 }
11462             }
11463         }
11464
11465       g_object_ref (tree_view->priv->model);
11466       g_signal_connect (tree_view->priv->model,
11467                         "row-changed",
11468                         G_CALLBACK (gtk_tree_view_row_changed),
11469                         tree_view);
11470       g_signal_connect (tree_view->priv->model,
11471                         "row-inserted",
11472                         G_CALLBACK (gtk_tree_view_row_inserted),
11473                         tree_view);
11474       g_signal_connect (tree_view->priv->model,
11475                         "row-has-child-toggled",
11476                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
11477                         tree_view);
11478       g_signal_connect (tree_view->priv->model,
11479                         "row-deleted",
11480                         G_CALLBACK (gtk_tree_view_row_deleted),
11481                         tree_view);
11482       g_signal_connect (tree_view->priv->model,
11483                         "rows-reordered",
11484                         G_CALLBACK (gtk_tree_view_rows_reordered),
11485                         tree_view);
11486
11487       flags = gtk_tree_model_get_flags (tree_view->priv->model);
11488       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
11489         tree_view->priv->is_list = TRUE;
11490       else
11491         tree_view->priv->is_list = FALSE;
11492
11493       path = gtk_tree_path_new_first ();
11494       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
11495         {
11496           tree_view->priv->tree = _gtk_rbtree_new ();
11497           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
11498           _gtk_tree_view_accessible_add (tree_view, tree_view->priv->tree, NULL);
11499         }
11500       gtk_tree_path_free (path);
11501
11502       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
11503       install_presize_handler (tree_view);
11504     }
11505
11506   gtk_tree_view_real_set_cursor (tree_view, NULL, CURSOR_INVALID);
11507
11508   g_object_notify (G_OBJECT (tree_view), "model");
11509
11510   if (tree_view->priv->selection)
11511   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
11512
11513   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11514     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11515 }
11516
11517 /**
11518  * gtk_tree_view_get_selection:
11519  * @tree_view: A #GtkTreeView.
11520  *
11521  * Gets the #GtkTreeSelection associated with @tree_view.
11522  *
11523  * Return value: (transfer none): A #GtkTreeSelection object.
11524  **/
11525 GtkTreeSelection *
11526 gtk_tree_view_get_selection (GtkTreeView *tree_view)
11527 {
11528   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11529
11530   return tree_view->priv->selection;
11531 }
11532
11533 /**
11534  * gtk_tree_view_get_hadjustment:
11535  * @tree_view: A #GtkTreeView
11536  *
11537  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
11538  *
11539  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11540  *     if none is currently being used.
11541  *
11542  * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment()
11543  **/
11544 GtkAdjustment *
11545 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
11546 {
11547   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11548
11549   return gtk_tree_view_do_get_hadjustment (tree_view);
11550 }
11551
11552 static GtkAdjustment *
11553 gtk_tree_view_do_get_hadjustment (GtkTreeView *tree_view)
11554 {
11555   return tree_view->priv->hadjustment;
11556 }
11557
11558 /**
11559  * gtk_tree_view_set_hadjustment:
11560  * @tree_view: A #GtkTreeView
11561  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11562  *
11563  * Sets the #GtkAdjustment for the current horizontal aspect.
11564  *
11565  * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment()
11566  **/
11567 void
11568 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
11569                                GtkAdjustment *adjustment)
11570 {
11571   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11572   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11573
11574   gtk_tree_view_do_set_hadjustment (tree_view, adjustment);
11575 }
11576
11577 static void
11578 gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
11579                                   GtkAdjustment *adjustment)
11580 {
11581   GtkTreeViewPrivate *priv = tree_view->priv;
11582
11583   if (adjustment && priv->hadjustment == adjustment)
11584     return;
11585
11586   if (priv->hadjustment != NULL)
11587     {
11588       g_signal_handlers_disconnect_by_func (priv->hadjustment,
11589                                             gtk_tree_view_adjustment_changed,
11590                                             tree_view);
11591       g_object_unref (priv->hadjustment);
11592     }
11593
11594   if (adjustment == NULL)
11595     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11596                                      0.0, 0.0, 0.0);
11597
11598   g_signal_connect (adjustment, "value-changed",
11599                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11600   priv->hadjustment = g_object_ref_sink (adjustment);
11601   /* FIXME: Adjustment should probably be populated here with fresh values, but
11602    * internal details are too complicated for me to decipher right now.
11603    */
11604   gtk_tree_view_adjustment_changed (NULL, tree_view);
11605
11606   g_object_notify (G_OBJECT (tree_view), "hadjustment");
11607 }
11608
11609 /**
11610  * gtk_tree_view_get_vadjustment:
11611  * @tree_view: A #GtkTreeView
11612  *
11613  * Gets the #GtkAdjustment currently being used for the vertical aspect.
11614  *
11615  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11616  *     if none is currently being used.
11617  *
11618  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
11619  **/
11620 GtkAdjustment *
11621 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
11622 {
11623   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11624
11625   return gtk_tree_view_do_get_vadjustment (tree_view);
11626 }
11627
11628 static GtkAdjustment *
11629 gtk_tree_view_do_get_vadjustment (GtkTreeView *tree_view)
11630 {
11631   return tree_view->priv->vadjustment;
11632 }
11633
11634 /**
11635  * gtk_tree_view_set_vadjustment:
11636  * @tree_view: A #GtkTreeView
11637  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11638  *
11639  * Sets the #GtkAdjustment for the current vertical aspect.
11640  *
11641  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
11642  **/
11643 void
11644 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
11645                                GtkAdjustment *adjustment)
11646 {
11647   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11648   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11649
11650   gtk_tree_view_do_set_vadjustment (tree_view, adjustment);
11651 }
11652
11653 static void
11654 gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
11655                                   GtkAdjustment *adjustment)
11656 {
11657   GtkTreeViewPrivate *priv = tree_view->priv;
11658
11659   if (adjustment && priv->vadjustment == adjustment)
11660     return;
11661
11662   if (priv->vadjustment != NULL)
11663     {
11664       g_signal_handlers_disconnect_by_func (priv->vadjustment,
11665                                             gtk_tree_view_adjustment_changed,
11666                                             tree_view);
11667       g_object_unref (priv->vadjustment);
11668     }
11669
11670   if (adjustment == NULL)
11671     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11672                                      0.0, 0.0, 0.0);
11673
11674   g_signal_connect (adjustment, "value-changed",
11675                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11676   priv->vadjustment = g_object_ref_sink (adjustment);
11677   /* FIXME: Adjustment should probably be populated here with fresh values, but
11678    * internal details are too complicated for me to decipher right now.
11679    */
11680   gtk_tree_view_adjustment_changed (NULL, tree_view);
11681   g_object_notify (G_OBJECT (tree_view), "vadjustment");
11682 }
11683
11684 /* Column and header operations */
11685
11686 /**
11687  * gtk_tree_view_get_headers_visible:
11688  * @tree_view: A #GtkTreeView.
11689  *
11690  * Returns %TRUE if the headers on the @tree_view are visible.
11691  *
11692  * Return value: Whether the headers are visible or not.
11693  **/
11694 gboolean
11695 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
11696 {
11697   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11698
11699   return tree_view->priv->headers_visible;
11700 }
11701
11702 /**
11703  * gtk_tree_view_set_headers_visible:
11704  * @tree_view: A #GtkTreeView.
11705  * @headers_visible: %TRUE if the headers are visible
11706  *
11707  * Sets the visibility state of the headers.
11708  **/
11709 void
11710 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
11711                                    gboolean     headers_visible)
11712 {
11713   gint x, y;
11714   GList *list;
11715   GtkTreeViewColumn *column;
11716   GtkAllocation allocation;
11717   GtkWidget *button;
11718
11719   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11720
11721   headers_visible = !! headers_visible;
11722
11723   if (tree_view->priv->headers_visible == headers_visible)
11724     return;
11725
11726   tree_view->priv->headers_visible = headers_visible == TRUE;
11727
11728   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11729     {
11730       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
11731       if (headers_visible)
11732         {
11733           gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11734           gdk_window_move_resize (tree_view->priv->bin_window,
11735                                   x, y  + gtk_tree_view_get_effective_header_height (tree_view),
11736                                   tree_view->priv->width, allocation.height -  + gtk_tree_view_get_effective_header_height (tree_view));
11737
11738           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
11739             gtk_tree_view_map_buttons (tree_view);
11740         }
11741       else
11742         {
11743           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
11744
11745           for (list = tree_view->priv->columns; list; list = list->next)
11746             {
11747               column = list->data;
11748               button = gtk_tree_view_column_get_button (column);
11749
11750               gtk_widget_hide (button);
11751               gtk_widget_unmap (button);
11752             }
11753           gdk_window_hide (tree_view->priv->header_window);
11754         }
11755     }
11756
11757   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11758   gtk_adjustment_configure (tree_view->priv->vadjustment,
11759                             gtk_adjustment_get_value (tree_view->priv->vadjustment),
11760                             0,
11761                             tree_view->priv->height,
11762                             gtk_adjustment_get_step_increment (tree_view->priv->vadjustment),
11763                             (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2,
11764                             allocation.height - gtk_tree_view_get_effective_header_height (tree_view));
11765
11766   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11767
11768   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11769 }
11770
11771 /**
11772  * gtk_tree_view_columns_autosize:
11773  * @tree_view: A #GtkTreeView.
11774  *
11775  * Resizes all columns to their optimal width. Only works after the
11776  * treeview has been realized.
11777  **/
11778 void
11779 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11780 {
11781   gboolean dirty = FALSE;
11782   GList *list;
11783   GtkTreeViewColumn *column;
11784
11785   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11786
11787   for (list = tree_view->priv->columns; list; list = list->next)
11788     {
11789       column = list->data;
11790       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11791         continue;
11792       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11793       dirty = TRUE;
11794     }
11795
11796   if (dirty)
11797     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11798 }
11799
11800 /**
11801  * gtk_tree_view_set_headers_clickable:
11802  * @tree_view: A #GtkTreeView.
11803  * @setting: %TRUE if the columns are clickable.
11804  *
11805  * Allow the column title buttons to be clicked.
11806  **/
11807 void
11808 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11809                                      gboolean   setting)
11810 {
11811   GList *list;
11812
11813   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11814
11815   for (list = tree_view->priv->columns; list; list = list->next)
11816     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11817
11818   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11819 }
11820
11821
11822 /**
11823  * gtk_tree_view_get_headers_clickable:
11824  * @tree_view: A #GtkTreeView.
11825  *
11826  * Returns whether all header columns are clickable.
11827  *
11828  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11829  *
11830  * Since: 2.10
11831  **/
11832 gboolean
11833 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11834 {
11835   GList *list;
11836
11837   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11838
11839   for (list = tree_view->priv->columns; list; list = list->next)
11840     if (!gtk_tree_view_column_get_clickable (GTK_TREE_VIEW_COLUMN (list->data)))
11841       return FALSE;
11842
11843   return TRUE;
11844 }
11845
11846 /**
11847  * gtk_tree_view_set_rules_hint
11848  * @tree_view: a #GtkTreeView
11849  * @setting: %TRUE if the tree requires reading across rows
11850  *
11851  * This function tells GTK+ that the user interface for your
11852  * application requires users to read across tree rows and associate
11853  * cells with one another. By default, GTK+ will then render the tree
11854  * with alternating row colors. Do <emphasis>not</emphasis> use it
11855  * just because you prefer the appearance of the ruled tree; that's a
11856  * question for the theme. Some themes will draw tree rows in
11857  * alternating colors even when rules are turned off, and users who
11858  * prefer that appearance all the time can choose those themes. You
11859  * should call this function only as a <emphasis>semantic</emphasis>
11860  * hint to the theme engine that your tree makes alternating colors
11861  * useful from a functional standpoint (since it has lots of columns,
11862  * generally).
11863  *
11864  **/
11865 void
11866 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11867                               gboolean      setting)
11868 {
11869   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11870
11871   setting = setting != FALSE;
11872
11873   if (tree_view->priv->has_rules != setting)
11874     {
11875       tree_view->priv->has_rules = setting;
11876       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11877     }
11878
11879   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11880 }
11881
11882 /**
11883  * gtk_tree_view_get_rules_hint
11884  * @tree_view: a #GtkTreeView
11885  *
11886  * Gets the setting set by gtk_tree_view_set_rules_hint().
11887  *
11888  * Return value: %TRUE if rules are useful for the user of this tree
11889  **/
11890 gboolean
11891 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11892 {
11893   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11894
11895   return tree_view->priv->has_rules;
11896 }
11897
11898 /* Public Column functions
11899  */
11900
11901 /**
11902  * gtk_tree_view_append_column:
11903  * @tree_view: A #GtkTreeView.
11904  * @column: The #GtkTreeViewColumn to add.
11905  *
11906  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11907  * mode enabled, then @column must have its "sizing" property set to be
11908  * GTK_TREE_VIEW_COLUMN_FIXED.
11909  *
11910  * Return value: The number of columns in @tree_view after appending.
11911  **/
11912 gint
11913 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11914                              GtkTreeViewColumn *column)
11915 {
11916   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11917   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11918   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11919
11920   return gtk_tree_view_insert_column (tree_view, column, -1);
11921 }
11922
11923 void
11924 _gtk_tree_view_reset_header_styles (GtkTreeView *tree_view)
11925 {
11926   GList *columns;
11927
11928   for (columns = tree_view->priv->columns; columns; columns = columns->next)
11929     {
11930       GtkTreeViewColumn *column = columns->data;
11931       GtkWidget *header_widget;
11932
11933       if (!gtk_tree_view_column_get_visible (column))
11934         continue;
11935
11936       header_widget = gtk_tree_view_column_get_widget (column);
11937
11938       if (!header_widget)
11939         header_widget = gtk_tree_view_column_get_button (column);
11940
11941       gtk_widget_reset_style (header_widget);
11942     }
11943 }
11944
11945
11946 /**
11947  * gtk_tree_view_remove_column:
11948  * @tree_view: A #GtkTreeView.
11949  * @column: The #GtkTreeViewColumn to remove.
11950  *
11951  * Removes @column from @tree_view.
11952  *
11953  * Return value: The number of columns in @tree_view after removing.
11954  **/
11955 gint
11956 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11957                              GtkTreeViewColumn *column)
11958 {
11959   guint position;
11960
11961   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11962   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11963   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1);
11964
11965   if (tree_view->priv->focus_column == column)
11966     _gtk_tree_view_set_focus_column (tree_view, NULL);
11967
11968   if (tree_view->priv->edited_column == column)
11969     {
11970       gtk_tree_view_stop_editing (tree_view, TRUE);
11971
11972       /* no need to, but just to be sure ... */
11973       tree_view->priv->edited_column = NULL;
11974     }
11975
11976   if (tree_view->priv->expander_column == column)
11977     tree_view->priv->expander_column = NULL;
11978
11979   g_signal_handlers_disconnect_by_func (column,
11980                                         G_CALLBACK (column_sizing_notify),
11981                                         tree_view);
11982
11983   _gtk_tree_view_column_unset_tree_view (column);
11984
11985   position = g_list_index (tree_view->priv->columns, column);
11986
11987   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11988   tree_view->priv->n_columns--;
11989
11990   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11991     {
11992       GList *list;
11993
11994       _gtk_tree_view_column_unrealize_button (column);
11995       for (list = tree_view->priv->columns; list; list = list->next)
11996         {
11997           GtkTreeViewColumn *tmp_column;
11998
11999           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
12000           if (gtk_tree_view_column_get_visible (tmp_column))
12001             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
12002         }
12003
12004       if (tree_view->priv->n_columns == 0 &&
12005           gtk_tree_view_get_headers_visible (tree_view))
12006         gdk_window_hide (tree_view->priv->header_window);
12007
12008       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12009     }
12010
12011   _gtk_tree_view_reset_header_styles (tree_view);
12012
12013   _gtk_tree_view_accessible_remove_column (tree_view, column, position);
12014
12015   g_object_unref (column);
12016   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12017
12018   return tree_view->priv->n_columns;
12019 }
12020
12021 /**
12022  * gtk_tree_view_insert_column:
12023  * @tree_view: A #GtkTreeView.
12024  * @column: The #GtkTreeViewColumn to be inserted.
12025  * @position: The position to insert @column in.
12026  *
12027  * This inserts the @column into the @tree_view at @position.  If @position is
12028  * -1, then the column is inserted at the end. If @tree_view has
12029  * "fixed_height" mode enabled, then @column must have its "sizing" property
12030  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
12031  *
12032  * Return value: The number of columns in @tree_view after insertion.
12033  **/
12034 gint
12035 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
12036                              GtkTreeViewColumn *column,
12037                              gint               position)
12038 {
12039   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12040   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
12041   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
12042
12043   if (tree_view->priv->fixed_height_mode)
12044     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
12045                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
12046
12047   if (position < 0 || position > tree_view->priv->n_columns)
12048     position = tree_view->priv->n_columns;
12049
12050   g_object_ref_sink (column);
12051
12052   if (tree_view->priv->n_columns == 0 &&
12053       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
12054       gtk_tree_view_get_headers_visible (tree_view))
12055     {
12056       gdk_window_show (tree_view->priv->header_window);
12057     }
12058
12059   g_signal_connect (column, "notify::sizing",
12060                     G_CALLBACK (column_sizing_notify), tree_view);
12061
12062   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
12063                                             column, position);
12064   tree_view->priv->n_columns++;
12065
12066   _gtk_tree_view_column_set_tree_view (column, tree_view);
12067
12068   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12069     {
12070       GList *list;
12071
12072       _gtk_tree_view_column_realize_button (column);
12073
12074       for (list = tree_view->priv->columns; list; list = list->next)
12075         {
12076           column = GTK_TREE_VIEW_COLUMN (list->data);
12077           if (gtk_tree_view_column_get_visible (column))
12078             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12079         }
12080       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12081     }
12082
12083   _gtk_tree_view_reset_header_styles (tree_view);
12084
12085   _gtk_tree_view_accessible_add_column (tree_view, column, position);
12086
12087   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12088
12089   return tree_view->priv->n_columns;
12090 }
12091
12092 /**
12093  * gtk_tree_view_insert_column_with_attributes:
12094  * @tree_view: A #GtkTreeView
12095  * @position: The position to insert the new column in
12096  * @title: The title to set the header to
12097  * @cell: The #GtkCellRenderer
12098  * @...: A %NULL-terminated list of attributes
12099  *
12100  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
12101  * @position.  If @position is -1, then the newly created column is inserted at
12102  * the end.  The column is initialized with the attributes given. If @tree_view
12103  * has "fixed_height" mode enabled, then the new column will have its sizing
12104  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12105  *
12106  * Return value: The number of columns in @tree_view after insertion.
12107  **/
12108 gint
12109 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
12110                                              gint             position,
12111                                              const gchar     *title,
12112                                              GtkCellRenderer *cell,
12113                                              ...)
12114 {
12115   GtkTreeViewColumn *column;
12116   gchar *attribute;
12117   va_list args;
12118   gint column_id;
12119
12120   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12121
12122   column = gtk_tree_view_column_new ();
12123   if (tree_view->priv->fixed_height_mode)
12124     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12125
12126   gtk_tree_view_column_set_title (column, title);
12127   gtk_tree_view_column_pack_start (column, cell, TRUE);
12128
12129   va_start (args, cell);
12130
12131   attribute = va_arg (args, gchar *);
12132
12133   while (attribute != NULL)
12134     {
12135       column_id = va_arg (args, gint);
12136       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
12137       attribute = va_arg (args, gchar *);
12138     }
12139
12140   va_end (args);
12141
12142   return gtk_tree_view_insert_column (tree_view, column, position);
12143 }
12144
12145 /**
12146  * gtk_tree_view_insert_column_with_data_func:
12147  * @tree_view: a #GtkTreeView
12148  * @position: Position to insert, -1 for append
12149  * @title: column title
12150  * @cell: cell renderer for column
12151  * @func: function to set attributes of cell renderer
12152  * @data: data for @func
12153  * @dnotify: destroy notifier for @data
12154  *
12155  * Convenience function that inserts a new column into the #GtkTreeView
12156  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
12157  * attributes (normally using data from the model). See also
12158  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
12159  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
12160  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12161  *
12162  * Return value: number of columns in the tree view post-insert
12163  **/
12164 gint
12165 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
12166                                              gint                       position,
12167                                              const gchar               *title,
12168                                              GtkCellRenderer           *cell,
12169                                              GtkTreeCellDataFunc        func,
12170                                              gpointer                   data,
12171                                              GDestroyNotify             dnotify)
12172 {
12173   GtkTreeViewColumn *column;
12174
12175   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12176
12177   column = gtk_tree_view_column_new ();
12178   if (tree_view->priv->fixed_height_mode)
12179     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12180
12181   gtk_tree_view_column_set_title (column, title);
12182   gtk_tree_view_column_pack_start (column, cell, TRUE);
12183   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
12184
12185   return gtk_tree_view_insert_column (tree_view, column, position);
12186 }
12187
12188 /**
12189  * gtk_tree_view_get_n_columns:
12190  * @tree_view: a #GtkTreeView
12191  *
12192  * Queries the number of columns in the given @tree_view.
12193  *
12194  * Returns: The number of columns in the @tree_view
12195  *
12196  * Since: 3.4
12197  **/
12198 guint
12199 gtk_tree_view_get_n_columns (GtkTreeView *tree_view)
12200 {
12201   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
12202
12203   return tree_view->priv->n_columns;
12204 }
12205
12206 /**
12207  * gtk_tree_view_get_column:
12208  * @tree_view: A #GtkTreeView.
12209  * @n: The position of the column, counting from 0.
12210  *
12211  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
12212  *
12213  * Return value: (transfer none): The #GtkTreeViewColumn, or %NULL if the
12214  *     position is outside the range of columns.
12215  **/
12216 GtkTreeViewColumn *
12217 gtk_tree_view_get_column (GtkTreeView *tree_view,
12218                           gint         n)
12219 {
12220   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12221
12222   if (n < 0 || n >= tree_view->priv->n_columns)
12223     return NULL;
12224
12225   if (tree_view->priv->columns == NULL)
12226     return NULL;
12227
12228   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
12229 }
12230
12231 /**
12232  * gtk_tree_view_get_columns:
12233  * @tree_view: A #GtkTreeView
12234  *
12235  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
12236  * The returned list must be freed with g_list_free ().
12237  *
12238  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
12239  **/
12240 GList *
12241 gtk_tree_view_get_columns (GtkTreeView *tree_view)
12242 {
12243   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12244
12245   return g_list_copy (tree_view->priv->columns);
12246 }
12247
12248 /**
12249  * gtk_tree_view_move_column_after:
12250  * @tree_view: A #GtkTreeView
12251  * @column: The #GtkTreeViewColumn to be moved.
12252  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
12253  *
12254  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
12255  * @column is placed in the first position.
12256  **/
12257 void
12258 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
12259                                  GtkTreeViewColumn *column,
12260                                  GtkTreeViewColumn *base_column)
12261 {
12262   GList *column_list_el, *base_el = NULL;
12263
12264   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12265
12266   column_list_el = g_list_find (tree_view->priv->columns, column);
12267   g_return_if_fail (column_list_el != NULL);
12268
12269   if (base_column)
12270     {
12271       base_el = g_list_find (tree_view->priv->columns, base_column);
12272       g_return_if_fail (base_el != NULL);
12273     }
12274
12275   if (column_list_el->prev == base_el)
12276     return;
12277
12278   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
12279   if (base_el == NULL)
12280     {
12281       column_list_el->prev = NULL;
12282       column_list_el->next = tree_view->priv->columns;
12283       if (column_list_el->next)
12284         column_list_el->next->prev = column_list_el;
12285       tree_view->priv->columns = column_list_el;
12286     }
12287   else
12288     {
12289       column_list_el->prev = base_el;
12290       column_list_el->next = base_el->next;
12291       if (column_list_el->next)
12292         column_list_el->next->prev = column_list_el;
12293       base_el->next = column_list_el;
12294     }
12295
12296   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12297     {
12298       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12299       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
12300     }
12301
12302   _gtk_tree_view_reset_header_styles (tree_view);
12303
12304   _gtk_tree_view_accessible_reorder_column (tree_view, column);
12305
12306   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12307 }
12308
12309 /**
12310  * gtk_tree_view_set_expander_column:
12311  * @tree_view: A #GtkTreeView
12312  * @column: %NULL, or the column to draw the expander arrow at.
12313  *
12314  * Sets the column to draw the expander arrow at. It must be in @tree_view.
12315  * If @column is %NULL, then the expander arrow is always at the first
12316  * visible column.
12317  *
12318  * If you do not want expander arrow to appear in your tree, set the
12319  * expander column to a hidden column.
12320  **/
12321 void
12322 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
12323                                    GtkTreeViewColumn *column)
12324 {
12325   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12326   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12327   g_return_if_fail (column == NULL || gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view));
12328
12329   if (tree_view->priv->expander_column != column)
12330     {
12331       tree_view->priv->expander_column = column;
12332       g_object_notify (G_OBJECT (tree_view), "expander-column");
12333     }
12334 }
12335
12336 /**
12337  * gtk_tree_view_get_expander_column:
12338  * @tree_view: A #GtkTreeView
12339  *
12340  * Returns the column that is the current expander column.
12341  * This column has the expander arrow drawn next to it.
12342  *
12343  * Return value: (transfer none): The expander column.
12344  **/
12345 GtkTreeViewColumn *
12346 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
12347 {
12348   GList *list;
12349
12350   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12351
12352   for (list = tree_view->priv->columns; list; list = list->next)
12353     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
12354       return (GtkTreeViewColumn *) list->data;
12355   return NULL;
12356 }
12357
12358
12359 /**
12360  * gtk_tree_view_set_column_drag_function:
12361  * @tree_view: A #GtkTreeView.
12362  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
12363  * @user_data: (allow-none): User data to be passed to @func, or %NULL
12364  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
12365  *
12366  * Sets a user function for determining where a column may be dropped when
12367  * dragged.  This function is called on every column pair in turn at the
12368  * beginning of a column drag to determine where a drop can take place.  The
12369  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
12370  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
12371  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
12372  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
12373  * @tree_view reverts to the default behavior of allowing all columns to be
12374  * dropped everywhere.
12375  **/
12376 void
12377 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
12378                                         GtkTreeViewColumnDropFunc  func,
12379                                         gpointer                   user_data,
12380                                         GDestroyNotify             destroy)
12381 {
12382   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12383
12384   if (tree_view->priv->column_drop_func_data_destroy)
12385     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
12386
12387   tree_view->priv->column_drop_func = func;
12388   tree_view->priv->column_drop_func_data = user_data;
12389   tree_view->priv->column_drop_func_data_destroy = destroy;
12390 }
12391
12392 /**
12393  * gtk_tree_view_scroll_to_point:
12394  * @tree_view: a #GtkTreeView
12395  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
12396  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
12397  *
12398  * Scrolls the tree view such that the top-left corner of the visible
12399  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
12400  * in tree coordinates.  The @tree_view must be realized before
12401  * this function is called.  If it isn't, you probably want to be
12402  * using gtk_tree_view_scroll_to_cell().
12403  *
12404  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
12405  **/
12406 void
12407 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
12408                                gint         tree_x,
12409                                gint         tree_y)
12410 {
12411   GtkAdjustment *hadj;
12412   GtkAdjustment *vadj;
12413
12414   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12415   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
12416
12417   hadj = tree_view->priv->hadjustment;
12418   vadj = tree_view->priv->vadjustment;
12419
12420   if (tree_x != -1)
12421     gtk_adjustment_set_value (hadj, tree_x);
12422   if (tree_y != -1)
12423     gtk_adjustment_set_value (vadj, tree_y);
12424 }
12425
12426 /**
12427  * gtk_tree_view_scroll_to_cell:
12428  * @tree_view: A #GtkTreeView.
12429  * @path: (allow-none): The path of the row to move to, or %NULL.
12430  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
12431  * @use_align: whether to use alignment arguments, or %FALSE.
12432  * @row_align: The vertical alignment of the row specified by @path.
12433  * @col_align: The horizontal alignment of the column specified by @column.
12434  *
12435  * Moves the alignments of @tree_view to the position specified by @column and
12436  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
12437  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
12438  * or @path need to be non-%NULL.  @row_align determines where the row is
12439  * placed, and @col_align determines where @column is placed.  Both are expected
12440  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
12441  * right/bottom alignment, 0.5 means center.
12442  *
12443  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
12444  * tree does the minimum amount of work to scroll the cell onto the screen.
12445  * This means that the cell will be scrolled to the edge closest to its current
12446  * position.  If the cell is currently visible on the screen, nothing is done.
12447  *
12448  * This function only works if the model is set, and @path is a valid row on the
12449  * model.  If the model changes before the @tree_view is realized, the centered
12450  * path will be modified to reflect this change.
12451  **/
12452 void
12453 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
12454                               GtkTreePath       *path,
12455                               GtkTreeViewColumn *column,
12456                               gboolean           use_align,
12457                               gfloat             row_align,
12458                               gfloat             col_align)
12459 {
12460   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12461   g_return_if_fail (tree_view->priv->model != NULL);
12462   g_return_if_fail (tree_view->priv->tree != NULL);
12463   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
12464   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
12465   g_return_if_fail (path != NULL || column != NULL);
12466
12467 #if 0
12468   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
12469            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
12470 #endif
12471   row_align = CLAMP (row_align, 0.0, 1.0);
12472   col_align = CLAMP (col_align, 0.0, 1.0);
12473
12474
12475   /* Note: Despite the benefits that come from having one code path for the
12476    * scrolling code, we short-circuit validate_visible_area's immplementation as
12477    * it is much slower than just going to the point.
12478    */
12479   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
12480       !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
12481       _gtk_widget_get_alloc_needed (GTK_WIDGET (tree_view)) ||
12482       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
12483     {
12484       if (tree_view->priv->scroll_to_path)
12485         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
12486
12487       tree_view->priv->scroll_to_path = NULL;
12488       tree_view->priv->scroll_to_column = NULL;
12489
12490       if (path)
12491         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
12492       if (column)
12493         tree_view->priv->scroll_to_column = column;
12494       tree_view->priv->scroll_to_use_align = use_align;
12495       tree_view->priv->scroll_to_row_align = row_align;
12496       tree_view->priv->scroll_to_col_align = col_align;
12497
12498       install_presize_handler (tree_view);
12499     }
12500   else
12501     {
12502       GdkRectangle cell_rect;
12503       GdkRectangle vis_rect;
12504       gint dest_x, dest_y;
12505
12506       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
12507       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
12508
12509       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
12510
12511       dest_x = vis_rect.x;
12512       dest_y = vis_rect.y;
12513
12514       if (column)
12515         {
12516           if (use_align)
12517             {
12518               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
12519             }
12520           else
12521             {
12522               if (cell_rect.x < vis_rect.x)
12523                 dest_x = cell_rect.x;
12524               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
12525                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
12526             }
12527         }
12528
12529       if (path)
12530         {
12531           if (use_align)
12532             {
12533               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
12534               dest_y = MAX (dest_y, 0);
12535             }
12536           else
12537             {
12538               if (cell_rect.y < vis_rect.y)
12539                 dest_y = cell_rect.y;
12540               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
12541                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
12542             }
12543         }
12544
12545       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
12546     }
12547 }
12548
12549 /**
12550  * gtk_tree_view_row_activated:
12551  * @tree_view: A #GtkTreeView
12552  * @path: The #GtkTreePath to be activated.
12553  * @column: The #GtkTreeViewColumn to be activated.
12554  *
12555  * Activates the cell determined by @path and @column.
12556  **/
12557 void
12558 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
12559                              GtkTreePath       *path,
12560                              GtkTreeViewColumn *column)
12561 {
12562   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12563
12564   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
12565 }
12566
12567
12568 static void
12569 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
12570                                           GtkRBNode *node,
12571                                           gpointer   data)
12572 {
12573   GtkTreeView *tree_view = data;
12574
12575   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
12576       node->children)
12577     {
12578       GtkTreePath *path;
12579       GtkTreeIter iter;
12580
12581       path = _gtk_tree_path_new_from_rbtree (tree, node);
12582       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12583
12584       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12585
12586       gtk_tree_path_free (path);
12587     }
12588
12589   if (node->children)
12590     _gtk_rbtree_traverse (node->children,
12591                           node->children->root,
12592                           G_PRE_ORDER,
12593                           gtk_tree_view_expand_all_emission_helper,
12594                           tree_view);
12595 }
12596
12597 /**
12598  * gtk_tree_view_expand_all:
12599  * @tree_view: A #GtkTreeView.
12600  *
12601  * Recursively expands all nodes in the @tree_view.
12602  **/
12603 void
12604 gtk_tree_view_expand_all (GtkTreeView *tree_view)
12605 {
12606   GtkTreePath *path;
12607   GtkRBTree *tree;
12608   GtkRBNode *node;
12609
12610   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12611
12612   if (tree_view->priv->tree == NULL)
12613     return;
12614
12615   path = gtk_tree_path_new_first ();
12616   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12617
12618   while (node)
12619     {
12620       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
12621       node = _gtk_rbtree_next (tree, node);
12622       gtk_tree_path_next (path);
12623   }
12624
12625   gtk_tree_path_free (path);
12626 }
12627
12628 /**
12629  * gtk_tree_view_collapse_all:
12630  * @tree_view: A #GtkTreeView.
12631  *
12632  * Recursively collapses all visible, expanded nodes in @tree_view.
12633  **/
12634 void
12635 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
12636 {
12637   GtkRBTree *tree;
12638   GtkRBNode *node;
12639   GtkTreePath *path;
12640   gint *indices;
12641
12642   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12643
12644   if (tree_view->priv->tree == NULL)
12645     return;
12646
12647   path = gtk_tree_path_new ();
12648   gtk_tree_path_down (path);
12649   indices = gtk_tree_path_get_indices (path);
12650
12651   tree = tree_view->priv->tree;
12652   node = _gtk_rbtree_first (tree);
12653
12654   while (node)
12655     {
12656       if (node->children)
12657         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12658       indices[0]++;
12659       node = _gtk_rbtree_next (tree, node);
12660     }
12661
12662   gtk_tree_path_free (path);
12663 }
12664
12665 /**
12666  * gtk_tree_view_expand_to_path:
12667  * @tree_view: A #GtkTreeView.
12668  * @path: path to a row.
12669  *
12670  * Expands the row at @path. This will also expand all parent rows of
12671  * @path as necessary.
12672  *
12673  * Since: 2.2
12674  **/
12675 void
12676 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
12677                               GtkTreePath *path)
12678 {
12679   gint i, depth;
12680   gint *indices;
12681   GtkTreePath *tmp;
12682
12683   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12684   g_return_if_fail (path != NULL);
12685
12686   depth = gtk_tree_path_get_depth (path);
12687   indices = gtk_tree_path_get_indices (path);
12688
12689   tmp = gtk_tree_path_new ();
12690   g_return_if_fail (tmp != NULL);
12691
12692   for (i = 0; i < depth; i++)
12693     {
12694       gtk_tree_path_append_index (tmp, indices[i]);
12695       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12696     }
12697
12698   gtk_tree_path_free (tmp);
12699 }
12700
12701 /* FIXME the bool return values for expand_row and collapse_row are
12702  * not analagous; they should be TRUE if the row had children and
12703  * was not already in the requested state.
12704  */
12705
12706
12707 static gboolean
12708 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12709                                GtkTreePath *path,
12710                                GtkRBTree   *tree,
12711                                GtkRBNode   *node,
12712                                gboolean     open_all,
12713                                gboolean     animate)
12714 {
12715   GtkTreeIter iter;
12716   GtkTreeIter temp;
12717   gboolean expand;
12718
12719   if (animate)
12720     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12721                   "gtk-enable-animations", &animate,
12722                   NULL);
12723
12724   remove_auto_expand_timeout (tree_view);
12725
12726   if (node->children && !open_all)
12727     return FALSE;
12728
12729   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12730     return FALSE;
12731
12732   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12733   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12734     return FALSE;
12735
12736
12737    if (node->children && open_all)
12738     {
12739       gboolean retval = FALSE;
12740       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12741
12742       gtk_tree_path_append_index (tmp_path, 0);
12743       tree = node->children;
12744       node = _gtk_rbtree_first (tree);
12745       /* try to expand the children */
12746       do
12747         {
12748          gboolean t;
12749          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12750                                             TRUE, animate);
12751          if (t)
12752            retval = TRUE;
12753
12754          gtk_tree_path_next (tmp_path);
12755          node = _gtk_rbtree_next (tree, node);
12756        }
12757       while (node != NULL);
12758
12759       gtk_tree_path_free (tmp_path);
12760
12761       return retval;
12762     }
12763
12764   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12765
12766   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12767     return FALSE;
12768
12769   if (expand)
12770     return FALSE;
12771
12772   node->children = _gtk_rbtree_new ();
12773   node->children->parent_tree = tree;
12774   node->children->parent_node = node;
12775
12776   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12777
12778   gtk_tree_view_build_tree (tree_view,
12779                             node->children,
12780                             &temp,
12781                             gtk_tree_path_get_depth (path) + 1,
12782                             open_all);
12783
12784   _gtk_tree_view_accessible_add (tree_view, node->children, NULL);
12785   _gtk_tree_view_accessible_add_state (tree_view,
12786                                        tree, node,
12787                                        GTK_CELL_RENDERER_EXPANDED);
12788
12789   if (animate)
12790     {
12791       GtkStyleContext *context;
12792
12793       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
12794
12795       gtk_style_context_save (context);
12796       gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
12797
12798       gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
12799                                              node, GTK_STATE_ACTIVE, TRUE);
12800
12801       _gtk_style_context_invalidate_animation_areas (context);
12802       gtk_style_context_restore (context);
12803     }
12804
12805   install_presize_handler (tree_view);
12806
12807   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12808   if (open_all && node->children)
12809     {
12810       _gtk_rbtree_traverse (node->children,
12811                             node->children->root,
12812                             G_PRE_ORDER,
12813                             gtk_tree_view_expand_all_emission_helper,
12814                             tree_view);
12815     }
12816   return TRUE;
12817 }
12818
12819
12820 /**
12821  * gtk_tree_view_expand_row:
12822  * @tree_view: a #GtkTreeView
12823  * @path: path to a row
12824  * @open_all: whether to recursively expand, or just expand immediate children
12825  *
12826  * Opens the row so its children are visible.
12827  *
12828  * Return value: %TRUE if the row existed and had children
12829  **/
12830 gboolean
12831 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12832                           GtkTreePath *path,
12833                           gboolean     open_all)
12834 {
12835   GtkRBTree *tree;
12836   GtkRBNode *node;
12837
12838   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12839   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12840   g_return_val_if_fail (path != NULL, FALSE);
12841
12842   if (_gtk_tree_view_find_node (tree_view,
12843                                 path,
12844                                 &tree,
12845                                 &node))
12846     return FALSE;
12847
12848   if (tree != NULL)
12849     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12850   else
12851     return FALSE;
12852 }
12853
12854 static gboolean
12855 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12856                                  GtkTreePath *path,
12857                                  GtkRBTree   *tree,
12858                                  GtkRBNode   *node,
12859                                  gboolean     animate)
12860 {
12861   GtkTreeIter iter;
12862   GtkTreeIter children;
12863   gboolean collapse;
12864   gint x, y;
12865   GList *list;
12866   GdkWindow *child;
12867   gboolean selection_changed, cursor_changed;
12868
12869   if (animate)
12870     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12871                   "gtk-enable-animations", &animate,
12872                   NULL);
12873
12874   remove_auto_expand_timeout (tree_view);
12875
12876   if (node->children == NULL)
12877     return FALSE;
12878   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12879
12880   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12881
12882   if (collapse)
12883     return FALSE;
12884
12885   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12886    * a chance to prelight the correct node below */
12887
12888   if (tree_view->priv->prelight_tree)
12889     {
12890       GtkRBTree *parent_tree;
12891       GtkRBNode *parent_node;
12892
12893       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12894       parent_node = tree_view->priv->prelight_tree->parent_node;
12895       while (parent_tree)
12896         {
12897           if (parent_tree == tree && parent_node == node)
12898             {
12899               ensure_unprelighted (tree_view);
12900               break;
12901             }
12902           parent_node = parent_tree->parent_node;
12903           parent_tree = parent_tree->parent_tree;
12904         }
12905     }
12906
12907   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12908
12909   for (list = tree_view->priv->columns; list; list = list->next)
12910     {
12911       GtkTreeViewColumn *column = list->data;
12912
12913       if (gtk_tree_view_column_get_visible (column) == FALSE)
12914         continue;
12915       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12916         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12917     }
12918
12919   if (tree_view->priv->destroy_count_func)
12920     {
12921       GtkTreePath *child_path;
12922       gint child_count = 0;
12923       child_path = gtk_tree_path_copy (path);
12924       gtk_tree_path_down (child_path);
12925       if (node->children)
12926         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12927       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12928       gtk_tree_path_free (child_path);
12929     }
12930
12931   if (tree_view->priv->cursor_node)
12932     {
12933       cursor_changed = (node->children == tree_view->priv->cursor_tree)
12934                        || _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree);
12935     }
12936   else
12937     cursor_changed = FALSE;
12938
12939   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12940     {
12941       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12942       if (gtk_tree_path_is_ancestor (path, anchor_path))
12943         {
12944           gtk_tree_row_reference_free (tree_view->priv->anchor);
12945           tree_view->priv->anchor = NULL;
12946         }
12947       gtk_tree_path_free (anchor_path);
12948     }
12949
12950   selection_changed = gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children);
12951
12952   /* Stop a pending double click */
12953   tree_view->priv->last_button_x = -1;
12954   tree_view->priv->last_button_y = -1;
12955
12956   _gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
12957   _gtk_tree_view_accessible_remove_state (tree_view,
12958                                           tree, node,
12959                                           GTK_CELL_RENDERER_EXPANDED);
12960
12961   _gtk_rbtree_remove (node->children);
12962
12963   if (cursor_changed)
12964     gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CURSOR_INVALID);
12965   if (selection_changed)
12966     g_signal_emit_by_name (tree_view->priv->selection, "changed");
12967
12968   if (animate)
12969     {
12970       GtkStyleContext *context;
12971
12972       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
12973
12974       gtk_style_context_save (context);
12975       gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
12976
12977       gtk_style_context_notify_state_change (context, tree_view->priv->bin_window,
12978                                              node, GTK_STATE_ACTIVE, FALSE);
12979
12980       _gtk_style_context_invalidate_animation_areas (context);
12981       gtk_style_context_restore (context);
12982     }
12983
12984   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12985     {
12986       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12987     }
12988
12989   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12990
12991   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12992     {
12993       /* now that we've collapsed all rows, we want to try to set the prelight
12994        * again. To do this, we fake a motion event and send it to ourselves. */
12995
12996       child = gdk_window_get_device_position (gdk_window_get_parent (tree_view->priv->bin_window),
12997                                               gdk_device_manager_get_client_pointer (
12998                                                 gdk_display_get_device_manager (
12999                                                   gtk_widget_get_display (GTK_WIDGET (tree_view)))),
13000                                               &x, &y, NULL);
13001       if (child == tree_view->priv->bin_window)
13002         {
13003           GdkEventMotion event;
13004           gint child_x, child_y;
13005
13006           gdk_window_get_position (child, &child_x, &child_y);
13007
13008           event.window = tree_view->priv->bin_window;
13009           event.x = x - child_x;
13010           event.y = y - child_y;
13011
13012           /* despite the fact this isn't a real event, I'm almost positive it will
13013            * never trigger a drag event.  maybe_drag is the only function that uses
13014            * more than just event.x and event.y. */
13015           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
13016         }
13017     }
13018
13019   return TRUE;
13020 }
13021
13022 /**
13023  * gtk_tree_view_collapse_row:
13024  * @tree_view: a #GtkTreeView
13025  * @path: path to a row in the @tree_view
13026  *
13027  * Collapses a row (hides its child rows, if they exist).
13028  *
13029  * Return value: %TRUE if the row was collapsed.
13030  **/
13031 gboolean
13032 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
13033                             GtkTreePath *path)
13034 {
13035   GtkRBTree *tree;
13036   GtkRBNode *node;
13037
13038   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13039   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
13040   g_return_val_if_fail (path != NULL, FALSE);
13041
13042   if (_gtk_tree_view_find_node (tree_view,
13043                                 path,
13044                                 &tree,
13045                                 &node))
13046     return FALSE;
13047
13048   if (tree == NULL || node->children == NULL)
13049     return FALSE;
13050
13051   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
13052 }
13053
13054 static void
13055 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
13056                                         GtkRBTree              *tree,
13057                                         GtkTreePath            *path,
13058                                         GtkTreeViewMappingFunc  func,
13059                                         gpointer                user_data)
13060 {
13061   GtkRBNode *node;
13062
13063   if (tree == NULL || tree->root == NULL)
13064     return;
13065
13066   node = _gtk_rbtree_first (tree);
13067
13068   while (node)
13069     {
13070       if (node->children)
13071         {
13072           (* func) (tree_view, path, user_data);
13073           gtk_tree_path_down (path);
13074           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
13075           gtk_tree_path_up (path);
13076         }
13077       gtk_tree_path_next (path);
13078       node = _gtk_rbtree_next (tree, node);
13079     }
13080 }
13081
13082 /**
13083  * gtk_tree_view_map_expanded_rows:
13084  * @tree_view: A #GtkTreeView
13085  * @func: (scope call): A function to be called
13086  * @data: User data to be passed to the function.
13087  *
13088  * Calls @func on all expanded rows.
13089  **/
13090 void
13091 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
13092                                  GtkTreeViewMappingFunc  func,
13093                                  gpointer                user_data)
13094 {
13095   GtkTreePath *path;
13096
13097   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13098   g_return_if_fail (func != NULL);
13099
13100   path = gtk_tree_path_new_first ();
13101
13102   gtk_tree_view_map_expanded_rows_helper (tree_view,
13103                                           tree_view->priv->tree,
13104                                           path, func, user_data);
13105
13106   gtk_tree_path_free (path);
13107 }
13108
13109 /**
13110  * gtk_tree_view_row_expanded:
13111  * @tree_view: A #GtkTreeView.
13112  * @path: A #GtkTreePath to test expansion state.
13113  *
13114  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
13115  *
13116  * Return value: %TRUE if #path is expanded.
13117  **/
13118 gboolean
13119 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
13120                             GtkTreePath *path)
13121 {
13122   GtkRBTree *tree;
13123   GtkRBNode *node;
13124
13125   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13126   g_return_val_if_fail (path != NULL, FALSE);
13127
13128   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13129
13130   if (node == NULL)
13131     return FALSE;
13132
13133   return (node->children != NULL);
13134 }
13135
13136 /**
13137  * gtk_tree_view_get_reorderable:
13138  * @tree_view: a #GtkTreeView
13139  *
13140  * Retrieves whether the user can reorder the tree via drag-and-drop. See
13141  * gtk_tree_view_set_reorderable().
13142  *
13143  * Return value: %TRUE if the tree can be reordered.
13144  **/
13145 gboolean
13146 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
13147 {
13148   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13149
13150   return tree_view->priv->reorderable;
13151 }
13152
13153 /**
13154  * gtk_tree_view_set_reorderable:
13155  * @tree_view: A #GtkTreeView.
13156  * @reorderable: %TRUE, if the tree can be reordered.
13157  *
13158  * This function is a convenience function to allow you to reorder
13159  * models that support the #GtkTreeDragSourceIface and the
13160  * #GtkTreeDragDestIface.  Both #GtkTreeStore and #GtkListStore support
13161  * these.  If @reorderable is %TRUE, then the user can reorder the
13162  * model by dragging and dropping rows. The developer can listen to
13163  * these changes by connecting to the model's row_inserted and
13164  * row_deleted signals. The reordering is implemented by setting up
13165  * the tree view as a drag source and destination. Therefore, drag and
13166  * drop can not be used in a reorderable view for any other purpose.
13167  *
13168  * This function does not give you any degree of control over the order -- any
13169  * reordering is allowed.  If more control is needed, you should probably
13170  * handle drag and drop manually.
13171  **/
13172 void
13173 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
13174                                gboolean     reorderable)
13175 {
13176   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13177
13178   reorderable = reorderable != FALSE;
13179
13180   if (tree_view->priv->reorderable == reorderable)
13181     return;
13182
13183   if (reorderable)
13184     {
13185       const GtkTargetEntry row_targets[] = {
13186         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
13187       };
13188
13189       gtk_tree_view_enable_model_drag_source (tree_view,
13190                                               GDK_BUTTON1_MASK,
13191                                               row_targets,
13192                                               G_N_ELEMENTS (row_targets),
13193                                               GDK_ACTION_MOVE);
13194       gtk_tree_view_enable_model_drag_dest (tree_view,
13195                                             row_targets,
13196                                             G_N_ELEMENTS (row_targets),
13197                                             GDK_ACTION_MOVE);
13198     }
13199   else
13200     {
13201       gtk_tree_view_unset_rows_drag_source (tree_view);
13202       gtk_tree_view_unset_rows_drag_dest (tree_view);
13203     }
13204
13205   tree_view->priv->reorderable = reorderable;
13206
13207   g_object_notify (G_OBJECT (tree_view), "reorderable");
13208 }
13209
13210 static void
13211 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
13212                                GtkTreePath     *path,
13213                                SetCursorFlags   flags)
13214 {
13215   if (!(flags & CURSOR_INVALID) && tree_view->priv->cursor_node)
13216     {
13217       _gtk_tree_view_accessible_remove_state (tree_view,
13218                                               tree_view->priv->cursor_tree,
13219                                               tree_view->priv->cursor_node,
13220                                               GTK_CELL_RENDERER_FOCUSED);
13221       _gtk_tree_view_queue_draw_node (tree_view,
13222                                       tree_view->priv->cursor_tree,
13223                                       tree_view->priv->cursor_node,
13224                                       NULL);
13225     }
13226
13227   /* One cannot set the cursor on a separator.   Also, if
13228    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
13229    * before finding the tree and node belonging to path.  The
13230    * path maps to a non-existing path and we will silently bail out.
13231    * We unset tree and node to avoid further processing.
13232    */
13233   if (path == NULL ||
13234       row_is_separator (tree_view, NULL, path)
13235       || _gtk_tree_view_find_node (tree_view,
13236                                    path,
13237                                    &tree_view->priv->cursor_tree,
13238                                    &tree_view->priv->cursor_node))
13239     {
13240       tree_view->priv->cursor_tree = NULL;
13241       tree_view->priv->cursor_node = NULL;
13242     }
13243
13244   if (tree_view->priv->cursor_node != NULL)
13245     {
13246       GtkRBTree *new_tree = NULL;
13247       GtkRBNode *new_node = NULL;
13248
13249       if ((flags & CLEAR_AND_SELECT) && !tree_view->priv->modify_selection_pressed)
13250         {
13251           GtkTreeSelectMode mode = 0;
13252
13253           if (tree_view->priv->extend_selection_pressed)
13254             mode |= GTK_TREE_SELECT_MODE_EXTEND;
13255
13256           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
13257                                                     tree_view->priv->cursor_node,
13258                                                     tree_view->priv->cursor_tree,
13259                                                     path,
13260                                                     mode,
13261                                                     FALSE);
13262         }
13263
13264       /* We have to re-find tree and node here again, somebody might have
13265        * cleared the node or the whole tree in the GtkTreeSelection::changed
13266        * callback. If the nodes differ we bail out here.
13267        */
13268       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
13269
13270       if (tree_view->priv->cursor_node != new_node)
13271         return;
13272
13273       if (flags & CLAMP_NODE)
13274         {
13275           gtk_tree_view_clamp_node_visible (tree_view,
13276                                             tree_view->priv->cursor_tree,
13277                                             tree_view->priv->cursor_node);
13278           _gtk_tree_view_queue_draw_node (tree_view,
13279                                           tree_view->priv->cursor_tree,
13280                                           tree_view->priv->cursor_node,
13281                                           NULL);
13282         }
13283
13284       _gtk_tree_view_accessible_add_state (tree_view,
13285                                            tree_view->priv->cursor_tree,
13286                                            tree_view->priv->cursor_node,
13287                                            GTK_CELL_RENDERER_FOCUSED);
13288     }
13289
13290   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
13291 }
13292
13293 /**
13294  * gtk_tree_view_get_cursor:
13295  * @tree_view: A #GtkTreeView
13296  * @path: (out) (transfer full) (allow-none): A pointer to be filled with the current cursor path, or %NULL
13297  * @focus_column: (out) (transfer none) (allow-none): A pointer to be filled with the current focus column, or %NULL
13298  *
13299  * Fills in @path and @focus_column with the current path and focus column.  If
13300  * the cursor isn't currently set, then *@path will be %NULL.  If no column
13301  * currently has focus, then *@focus_column will be %NULL.
13302  *
13303  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
13304  * you are done with it.
13305  **/
13306 void
13307 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
13308                           GtkTreePath       **path,
13309                           GtkTreeViewColumn **focus_column)
13310 {
13311   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13312
13313   if (path)
13314     {
13315       if (tree_view->priv->cursor_node)
13316         *path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
13317                                                 tree_view->priv->cursor_node);
13318       else
13319         *path = NULL;
13320     }
13321
13322   if (focus_column)
13323     {
13324       *focus_column = tree_view->priv->focus_column;
13325     }
13326 }
13327
13328 /**
13329  * gtk_tree_view_set_cursor:
13330  * @tree_view: A #GtkTreeView
13331  * @path: A #GtkTreePath
13332  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13333  * @start_editing: %TRUE if the specified cell should start being edited.
13334  *
13335  * Sets the current keyboard focus to be at @path, and selects it.  This is
13336  * useful when you want to focus the user's attention on a particular row.  If
13337  * @focus_column is not %NULL, then focus is given to the column specified by
13338  * it. Additionally, if @focus_column is specified, and @start_editing is
13339  * %TRUE, then editing should be started in the specified cell.
13340  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
13341  * in order to give keyboard focus to the widget.  Please note that editing
13342  * can only happen when the widget is realized.
13343  *
13344  * If @path is invalid for @model, the current cursor (if any) will be unset
13345  * and the function will return without failing.
13346  **/
13347 void
13348 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
13349                           GtkTreePath       *path,
13350                           GtkTreeViewColumn *focus_column,
13351                           gboolean           start_editing)
13352 {
13353   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
13354                                     NULL, start_editing);
13355 }
13356
13357 /**
13358  * gtk_tree_view_set_cursor_on_cell:
13359  * @tree_view: A #GtkTreeView
13360  * @path: A #GtkTreePath
13361  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13362  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
13363  * @start_editing: %TRUE if the specified cell should start being edited.
13364  *
13365  * Sets the current keyboard focus to be at @path, and selects it.  This is
13366  * useful when you want to focus the user's attention on a particular row.  If
13367  * @focus_column is not %NULL, then focus is given to the column specified by
13368  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
13369  * contains 2 or more editable or activatable cells, then focus is given to
13370  * the cell specified by @focus_cell. Additionally, if @focus_column is
13371  * specified, and @start_editing is %TRUE, then editing should be started in
13372  * the specified cell.  This function is often followed by
13373  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
13374  * widget.  Please note that editing can only happen when the widget is
13375  * realized.
13376  *
13377  * If @path is invalid for @model, the current cursor (if any) will be unset
13378  * and the function will return without failing.
13379  *
13380  * Since: 2.2
13381  **/
13382 void
13383 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
13384                                   GtkTreePath       *path,
13385                                   GtkTreeViewColumn *focus_column,
13386                                   GtkCellRenderer   *focus_cell,
13387                                   gboolean           start_editing)
13388 {
13389   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13390   g_return_if_fail (path != NULL);
13391   g_return_if_fail (focus_column == NULL || GTK_IS_TREE_VIEW_COLUMN (focus_column));
13392
13393   if (!tree_view->priv->model)
13394     return;
13395
13396   if (focus_cell)
13397     {
13398       g_return_if_fail (focus_column);
13399       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
13400     }
13401
13402   /* cancel the current editing, if it exists */
13403   if (tree_view->priv->edited_column &&
13404       gtk_cell_area_get_edit_widget
13405       (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column))))
13406     gtk_tree_view_stop_editing (tree_view, TRUE);
13407
13408   gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
13409
13410   if (focus_column &&
13411       gtk_tree_view_column_get_visible (focus_column))
13412     {
13413       GList *list;
13414       gboolean column_in_tree = FALSE;
13415
13416       for (list = tree_view->priv->columns; list; list = list->next)
13417         if (list->data == focus_column)
13418           {
13419             column_in_tree = TRUE;
13420             break;
13421           }
13422       g_return_if_fail (column_in_tree);
13423       _gtk_tree_view_set_focus_column (tree_view, focus_column);
13424       if (focus_cell)
13425         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
13426       if (start_editing)
13427         gtk_tree_view_start_editing (tree_view, path, TRUE);
13428     }
13429 }
13430
13431 /**
13432  * gtk_tree_view_get_bin_window:
13433  * @tree_view: A #GtkTreeView
13434  *
13435  * Returns the window that @tree_view renders to.
13436  * This is used primarily to compare to <literal>event->window</literal>
13437  * to confirm that the event on @tree_view is on the right window.
13438  *
13439  * Return value: (transfer none): A #GdkWindow, or %NULL when @tree_view
13440  *     hasn't been realized yet
13441  **/
13442 GdkWindow *
13443 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
13444 {
13445   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13446
13447   return tree_view->priv->bin_window;
13448 }
13449
13450 /**
13451  * gtk_tree_view_get_path_at_pos:
13452  * @tree_view: A #GtkTreeView.
13453  * @x: The x position to be identified (relative to bin_window).
13454  * @y: The y position to be identified (relative to bin_window).
13455  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
13456  * @column: (out) (transfer none) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
13457  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
13458  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
13459  *
13460  * Finds the path at the point (@x, @y), relative to bin_window coordinates
13461  * (please see gtk_tree_view_get_bin_window()).
13462  * That is, @x and @y are relative to an events coordinates. @x and @y must
13463  * come from an event on the @tree_view only where <literal>event->window ==
13464  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
13465  * things like popup menus. If @path is non-%NULL, then it will be filled
13466  * with the #GtkTreePath at that point.  This path should be freed with
13467  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
13468  * with the column at that point.  @cell_x and @cell_y return the coordinates
13469  * relative to the cell background (i.e. the @background_area passed to
13470  * gtk_cell_renderer_render()).  This function is only meaningful if
13471  * @tree_view is realized.  Therefore this function will always return %FALSE
13472  * if @tree_view is not realized or does not have a model.
13473  *
13474  * For converting widget coordinates (eg. the ones you get from
13475  * GtkWidget::query-tooltip), please see
13476  * gtk_tree_view_convert_widget_to_bin_window_coords().
13477  *
13478  * Return value: %TRUE if a row exists at that coordinate.
13479  **/
13480 gboolean
13481 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
13482                                gint                x,
13483                                gint                y,
13484                                GtkTreePath       **path,
13485                                GtkTreeViewColumn **column,
13486                                gint               *cell_x,
13487                                gint               *cell_y)
13488 {
13489   GtkRBTree *tree;
13490   GtkRBNode *node;
13491   gint y_offset;
13492
13493   g_return_val_if_fail (tree_view != NULL, FALSE);
13494
13495   if (path)
13496     *path = NULL;
13497   if (column)
13498     *column = NULL;
13499
13500   if (tree_view->priv->bin_window == NULL)
13501     return FALSE;
13502
13503   if (tree_view->priv->tree == NULL)
13504     return FALSE;
13505
13506   if (x > gtk_adjustment_get_upper (tree_view->priv->hadjustment))
13507     return FALSE;
13508
13509   if (x < 0 || y < 0)
13510     return FALSE;
13511
13512   if (column || cell_x)
13513     {
13514       GtkTreeViewColumn *tmp_column;
13515       GtkTreeViewColumn *last_column = NULL;
13516       GList *list;
13517       gint remaining_x = x;
13518       gboolean found = FALSE;
13519       gboolean rtl;
13520       gint width;
13521
13522       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
13523       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13524            list;
13525            list = (rtl ? list->prev : list->next))
13526         {
13527           tmp_column = list->data;
13528
13529           if (gtk_tree_view_column_get_visible (tmp_column) == FALSE)
13530             continue;
13531
13532           last_column = tmp_column;
13533           width = gtk_tree_view_column_get_width (tmp_column);
13534           if (remaining_x <= width)
13535             {
13536               found = TRUE;
13537
13538               if (column)
13539                 *column = tmp_column;
13540
13541               if (cell_x)
13542                 *cell_x = remaining_x;
13543
13544               break;
13545             }
13546           remaining_x -= width;
13547         }
13548
13549       /* If found is FALSE and there is a last_column, then it the remainder
13550        * space is in that area
13551        */
13552       if (!found)
13553         {
13554           if (last_column)
13555             {
13556               if (column)
13557                 *column = last_column;
13558
13559               if (cell_x)
13560                 *cell_x = gtk_tree_view_column_get_width (last_column) + remaining_x;
13561             }
13562           else
13563             {
13564               return FALSE;
13565             }
13566         }
13567     }
13568
13569   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
13570                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
13571                                       &tree, &node);
13572
13573   if (tree == NULL)
13574     return FALSE;
13575
13576   if (cell_y)
13577     *cell_y = y_offset;
13578
13579   if (path)
13580     *path = _gtk_tree_path_new_from_rbtree (tree, node);
13581
13582   return TRUE;
13583 }
13584
13585
13586 static inline gint
13587 gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
13588                                     GtkRBNode   *node,
13589                                     gint         vertical_separator)
13590 {
13591   int height;
13592
13593   /* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
13594    * i.e. just the cells, no spacing.
13595    *
13596    * The cell area height is at least expander_size - vertical_separator.
13597    * For regular nodes, the height is then at least expander_size. We should
13598    * be able to enforce the expander_size minimum here, because this
13599    * function will not be called for irregular (e.g. separator) rows.
13600    */
13601   height = gtk_tree_view_get_row_height (tree_view, node);
13602   if (height < tree_view->priv->expander_size)
13603     height = tree_view->priv->expander_size;
13604
13605   return height - vertical_separator;
13606 }
13607
13608 static inline gint
13609 gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
13610                                       GtkRBTree   *tree,
13611                                       GtkRBNode   *node,
13612                                       gint         vertical_separator)
13613 {
13614   int offset;
13615
13616   offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13617   offset += vertical_separator / 2;
13618
13619   return offset;
13620 }
13621
13622 /**
13623  * gtk_tree_view_get_cell_area:
13624  * @tree_view: a #GtkTreeView
13625  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13626  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
13627  * @rect: (out): rectangle to fill with cell rect
13628  *
13629  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13630  * row specified by @path and the column specified by @column.  If @path is
13631  * %NULL, or points to a path not currently displayed, the @y and @height fields
13632  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13633  * fields will be filled with 0.  The sum of all cell rects does not cover the
13634  * entire tree; there are extra pixels in between rows, for example. The
13635  * returned rectangle is equivalent to the @cell_area passed to
13636  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
13637  * realized.
13638  **/
13639 void
13640 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
13641                              GtkTreePath        *path,
13642                              GtkTreeViewColumn  *column,
13643                              GdkRectangle       *rect)
13644 {
13645   GtkRBTree *tree = NULL;
13646   GtkRBNode *node = NULL;
13647   gint vertical_separator;
13648   gint horizontal_separator;
13649
13650   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13651   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13652   g_return_if_fail (rect != NULL);
13653   g_return_if_fail (!column || gtk_tree_view_column_get_tree_view (column) == (GtkWidget *) tree_view);
13654   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
13655
13656   gtk_widget_style_get (GTK_WIDGET (tree_view),
13657                         "vertical-separator", &vertical_separator,
13658                         "horizontal-separator", &horizontal_separator,
13659                         NULL);
13660
13661   rect->x = 0;
13662   rect->y = 0;
13663   rect->width = 0;
13664   rect->height = 0;
13665
13666   if (column)
13667     {
13668       rect->x = gtk_tree_view_column_get_x_offset (column) + horizontal_separator/2;
13669       rect->width = gtk_tree_view_column_get_width (column) - horizontal_separator;
13670     }
13671
13672   if (path)
13673     {
13674       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13675
13676       /* Get vertical coords */
13677       if ((!ret && tree == NULL) || ret)
13678         return;
13679
13680       if (row_is_separator (tree_view, NULL, path))
13681         {
13682           /* There isn't really a "cell area" for separator, so we
13683            * return the y, height values for background area instead.
13684            */
13685           rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13686           rect->height = gtk_tree_view_get_row_height (tree_view, node);
13687         }
13688       else
13689         {
13690           rect->y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
13691                                                           vertical_separator);
13692           rect->height = gtk_tree_view_get_cell_area_height (tree_view, node,
13693                                                              vertical_separator);
13694         }
13695
13696       if (column &&
13697           gtk_tree_view_is_expander_column (tree_view, column))
13698         {
13699           gint depth = gtk_tree_path_get_depth (path);
13700           gboolean rtl;
13701
13702           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13703
13704           if (!rtl)
13705             rect->x += (depth - 1) * tree_view->priv->level_indentation;
13706           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
13707
13708           if (gtk_tree_view_draw_expanders (tree_view))
13709             {
13710               if (!rtl)
13711                 rect->x += depth * tree_view->priv->expander_size;
13712               rect->width -= depth * tree_view->priv->expander_size;
13713             }
13714
13715           rect->width = MAX (rect->width, 0);
13716         }
13717     }
13718 }
13719
13720 static inline gint
13721 gtk_tree_view_get_row_height (GtkTreeView *tree_view,
13722                               GtkRBNode   *node)
13723 {
13724   int height;
13725
13726   /* The "background" areas of all rows/cells add up to cover the entire tree.
13727    * The background includes all inter-row and inter-cell spacing.
13728    *
13729    * If the row pointed at by node does not have a height set, we default
13730    * to expander_size, which is the minimum height for regular nodes.
13731    * Non-regular nodes (e.g. separators) can have a height set smaller
13732    * than expander_size and should not be overruled here.
13733    */
13734   height = GTK_RBNODE_GET_HEIGHT (node);
13735   if (height <= 0)
13736     height = tree_view->priv->expander_size;
13737
13738   return height;
13739 }
13740
13741 static inline gint
13742 gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
13743                                 GtkRBTree   *tree,
13744                                 GtkRBNode   *node)
13745 {
13746   int offset;
13747
13748   offset = _gtk_rbtree_node_find_offset (tree, node);
13749
13750   return RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, offset);
13751 }
13752
13753 /**
13754  * gtk_tree_view_get_background_area:
13755  * @tree_view: a #GtkTreeView
13756  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13757  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
13758  * @rect: (out): rectangle to fill with cell background rect
13759  *
13760  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13761  * row specified by @path and the column specified by @column.  If @path is
13762  * %NULL, or points to a node not found in the tree, the @y and @height fields of
13763  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13764  * fields will be filled with 0.  The returned rectangle is equivalent to the
13765  * @background_area passed to gtk_cell_renderer_render().  These background
13766  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
13767  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
13768  * itself, excluding surrounding borders and the tree expander area.
13769  *
13770  **/
13771 void
13772 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
13773                                    GtkTreePath        *path,
13774                                    GtkTreeViewColumn  *column,
13775                                    GdkRectangle       *rect)
13776 {
13777   GtkRBTree *tree = NULL;
13778   GtkRBNode *node = NULL;
13779
13780   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13781   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13782   g_return_if_fail (rect != NULL);
13783
13784   rect->x = 0;
13785   rect->y = 0;
13786   rect->width = 0;
13787   rect->height = 0;
13788
13789   if (path)
13790     {
13791       /* Get vertical coords */
13792
13793       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
13794           tree == NULL)
13795         return;
13796
13797       rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13798       rect->height = gtk_tree_view_get_row_height (tree_view, node);
13799     }
13800
13801   if (column)
13802     {
13803       gint x2 = 0;
13804
13805       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
13806       rect->width = x2 - rect->x;
13807     }
13808 }
13809
13810 /**
13811  * gtk_tree_view_get_visible_rect:
13812  * @tree_view: a #GtkTreeView
13813  * @visible_rect: (out): rectangle to fill
13814  *
13815  * Fills @visible_rect with the currently-visible region of the
13816  * buffer, in tree coordinates. Convert to bin_window coordinates with
13817  * gtk_tree_view_convert_tree_to_bin_window_coords().
13818  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
13819  * scrollable area of the tree.
13820  **/
13821 void
13822 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
13823                                 GdkRectangle *visible_rect)
13824 {
13825   GtkAllocation allocation;
13826   GtkWidget *widget;
13827
13828   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13829
13830   widget = GTK_WIDGET (tree_view);
13831
13832   if (visible_rect)
13833     {
13834       gtk_widget_get_allocation (widget, &allocation);
13835       visible_rect->x = gtk_adjustment_get_value (tree_view->priv->hadjustment);
13836       visible_rect->y = gtk_adjustment_get_value (tree_view->priv->vadjustment);
13837       visible_rect->width = allocation.width;
13838       visible_rect->height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
13839     }
13840 }
13841
13842 /**
13843  * gtk_tree_view_convert_widget_to_tree_coords:
13844  * @tree_view: a #GtkTreeView
13845  * @wx: X coordinate relative to the widget
13846  * @wy: Y coordinate relative to the widget
13847  * @tx: (out): return location for tree X coordinate
13848  * @ty: (out): return location for tree Y coordinate
13849  *
13850  * Converts widget coordinates to coordinates for the
13851  * tree (the full scrollable area of the tree).
13852  *
13853  * Since: 2.12
13854  **/
13855 void
13856 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13857                                              gint         wx,
13858                                              gint         wy,
13859                                              gint        *tx,
13860                                              gint        *ty)
13861 {
13862   gint x, y;
13863
13864   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13865
13866   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13867                                                      wx, wy,
13868                                                      &x, &y);
13869   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13870                                                    x, y,
13871                                                    tx, ty);
13872 }
13873
13874 /**
13875  * gtk_tree_view_convert_tree_to_widget_coords:
13876  * @tree_view: a #GtkTreeView
13877  * @tx: X coordinate relative to the tree
13878  * @ty: Y coordinate relative to the tree
13879  * @wx: (out): return location for widget X coordinate
13880  * @wy: (out): return location for widget Y coordinate
13881  *
13882  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13883  * to widget coordinates.
13884  *
13885  * Since: 2.12
13886  **/
13887 void
13888 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13889                                              gint         tx,
13890                                              gint         ty,
13891                                              gint        *wx,
13892                                              gint        *wy)
13893 {
13894   gint x, y;
13895
13896   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13897
13898   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13899                                                    tx, ty,
13900                                                    &x, &y);
13901   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13902                                                      x, y,
13903                                                      wx, wy);
13904 }
13905
13906 /**
13907  * gtk_tree_view_convert_widget_to_bin_window_coords:
13908  * @tree_view: a #GtkTreeView
13909  * @wx: X coordinate relative to the widget
13910  * @wy: Y coordinate relative to the widget
13911  * @bx: (out): return location for bin_window X coordinate
13912  * @by: (out): return location for bin_window Y coordinate
13913  *
13914  * Converts widget coordinates to coordinates for the bin_window
13915  * (see gtk_tree_view_get_bin_window()).
13916  *
13917  * Since: 2.12
13918  **/
13919 void
13920 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13921                                                    gint         wx,
13922                                                    gint         wy,
13923                                                    gint        *bx,
13924                                                    gint        *by)
13925 {
13926   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13927
13928   if (bx)
13929     *bx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
13930   if (by)
13931     *by = wy - gtk_tree_view_get_effective_header_height (tree_view);
13932 }
13933
13934 /**
13935  * gtk_tree_view_convert_bin_window_to_widget_coords:
13936  * @tree_view: a #GtkTreeView
13937  * @bx: bin_window X coordinate
13938  * @by: bin_window Y coordinate
13939  * @wx: (out): return location for widget X coordinate
13940  * @wy: (out): return location for widget Y coordinate
13941  *
13942  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13943  * to widget relative coordinates.
13944  *
13945  * Since: 2.12
13946  **/
13947 void
13948 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13949                                                    gint         bx,
13950                                                    gint         by,
13951                                                    gint        *wx,
13952                                                    gint        *wy)
13953 {
13954   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13955
13956   if (wx)
13957     *wx = bx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
13958   if (wy)
13959     *wy = by + gtk_tree_view_get_effective_header_height (tree_view);
13960 }
13961
13962 /**
13963  * gtk_tree_view_convert_tree_to_bin_window_coords:
13964  * @tree_view: a #GtkTreeView
13965  * @tx: tree X coordinate
13966  * @ty: tree Y coordinate
13967  * @bx: (out): return location for X coordinate relative to bin_window
13968  * @by: (out): return location for Y coordinate relative to bin_window
13969  *
13970  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13971  * to bin_window coordinates.
13972  *
13973  * Since: 2.12
13974  **/
13975 void
13976 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13977                                                  gint         tx,
13978                                                  gint         ty,
13979                                                  gint        *bx,
13980                                                  gint        *by)
13981 {
13982   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13983
13984   if (bx)
13985     *bx = tx;
13986   if (by)
13987     *by = ty - tree_view->priv->dy;
13988 }
13989
13990 /**
13991  * gtk_tree_view_convert_bin_window_to_tree_coords:
13992  * @tree_view: a #GtkTreeView
13993  * @bx: X coordinate relative to bin_window
13994  * @by: Y coordinate relative to bin_window
13995  * @tx: (out): return location for tree X coordinate
13996  * @ty: (out): return location for tree Y coordinate
13997  *
13998  * Converts bin_window coordinates to coordinates for the
13999  * tree (the full scrollable area of the tree).
14000  *
14001  * Since: 2.12
14002  **/
14003 void
14004 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
14005                                                  gint         bx,
14006                                                  gint         by,
14007                                                  gint        *tx,
14008                                                  gint        *ty)
14009 {
14010   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14011
14012   if (tx)
14013     *tx = bx;
14014   if (ty)
14015     *ty = by + tree_view->priv->dy;
14016 }
14017
14018
14019
14020 /**
14021  * gtk_tree_view_get_visible_range:
14022  * @tree_view: A #GtkTreeView
14023  * @start_path: (out) (allow-none): Return location for start of region,
14024  *              or %NULL.
14025  * @end_path: (out) (allow-none): Return location for end of region, or %NULL.
14026  *
14027  * Sets @start_path and @end_path to be the first and last visible path.
14028  * Note that there may be invisible paths in between.
14029  *
14030  * The paths should be freed with gtk_tree_path_free() after use.
14031  *
14032  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
14033  *
14034  * Since: 2.8
14035  **/
14036 gboolean
14037 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
14038                                  GtkTreePath **start_path,
14039                                  GtkTreePath **end_path)
14040 {
14041   GtkRBTree *tree;
14042   GtkRBNode *node;
14043   gboolean retval;
14044
14045   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14046
14047   if (!tree_view->priv->tree)
14048     return FALSE;
14049
14050   retval = TRUE;
14051
14052   if (start_path)
14053     {
14054       _gtk_rbtree_find_offset (tree_view->priv->tree,
14055                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
14056                                &tree, &node);
14057       if (node)
14058         *start_path = _gtk_tree_path_new_from_rbtree (tree, node);
14059       else
14060         retval = FALSE;
14061     }
14062
14063   if (end_path)
14064     {
14065       gint y;
14066
14067       if (tree_view->priv->height < gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
14068         y = tree_view->priv->height - 1;
14069       else
14070         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1;
14071
14072       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
14073       if (node)
14074         *end_path = _gtk_tree_path_new_from_rbtree (tree, node);
14075       else
14076         retval = FALSE;
14077     }
14078
14079   return retval;
14080 }
14081
14082 /**
14083  * gtk_tree_view_is_blank_at_pos:
14084  * @tree_view: A #GtkTreeView
14085  * @x: The x position to be identified (relative to bin_window)
14086  * @y: The y position to be identified (relative to bin_window)
14087  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
14088  * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
14089  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
14090  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
14091  *
14092  * Determine whether the point (@x, @y) in @tree_view is blank, that is no
14093  * cell content nor an expander arrow is drawn at the location. If so, the
14094  * location can be considered as the background. You might wish to take
14095  * special action on clicks on the background, such as clearing a current
14096  * selection, having a custom context menu or starting rubber banding.
14097  *
14098  * The @x and @y coordinate that are provided must be relative to bin_window
14099  * coordinates.  That is, @x and @y must come from an event on @tree_view
14100  * where <literal>event->window == gtk_tree_view_get_bin_window (<!-- -->)</literal>.
14101  *
14102  * For converting widget coordinates (eg. the ones you get from
14103  * GtkWidget::query-tooltip), please see
14104  * gtk_tree_view_convert_widget_to_bin_window_coords().
14105  *
14106  * The @path, @column, @cell_x and @cell_y arguments will be filled in
14107  * likewise as for gtk_tree_view_get_path_at_pos().  Please see
14108  * gtk_tree_view_get_path_at_pos() for more information.
14109  *
14110  * Return value: %TRUE if the area at the given coordinates is blank,
14111  * %FALSE otherwise.
14112  *
14113  * Since: 3.0
14114  */
14115 gboolean
14116 gtk_tree_view_is_blank_at_pos (GtkTreeView       *tree_view,
14117                                gint                x,
14118                                gint                y,
14119                                GtkTreePath       **path,
14120                                GtkTreeViewColumn **column,
14121                                gint               *cell_x,
14122                                gint               *cell_y)
14123 {
14124   GtkRBTree *tree;
14125   GtkRBNode *node;
14126   GtkTreeIter iter;
14127   GtkTreePath *real_path;
14128   GtkTreeViewColumn *real_column;
14129   GdkRectangle cell_area, background_area;
14130
14131   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14132
14133   if (!gtk_tree_view_get_path_at_pos (tree_view, x, y,
14134                                       &real_path, &real_column,
14135                                       cell_x, cell_y))
14136     /* If there's no path here, it is blank */
14137     return TRUE;
14138
14139   if (path)
14140     *path = real_path;
14141
14142   if (column)
14143     *column = real_column;
14144
14145   gtk_tree_model_get_iter (tree_view->priv->model, &iter, real_path);
14146   _gtk_tree_view_find_node (tree_view, real_path, &tree, &node);
14147
14148   /* Check if there's an expander arrow at (x, y) */
14149   if (real_column == tree_view->priv->expander_column
14150       && gtk_tree_view_draw_expanders (tree_view))
14151     {
14152       gboolean over_arrow;
14153
14154       over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
14155
14156       if (over_arrow)
14157         {
14158           if (!path)
14159             gtk_tree_path_free (real_path);
14160           return FALSE;
14161         }
14162     }
14163
14164   /* Otherwise, have the column see if there's a cell at (x, y) */
14165   gtk_tree_view_column_cell_set_cell_data (real_column,
14166                                            tree_view->priv->model,
14167                                            &iter,
14168                                            GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14169                                            node->children ? TRUE : FALSE);
14170
14171   gtk_tree_view_get_background_area (tree_view, real_path, real_column,
14172                                      &background_area);
14173   gtk_tree_view_get_cell_area (tree_view, real_path, real_column,
14174                                &cell_area);
14175
14176   if (!path)
14177     gtk_tree_path_free (real_path);
14178
14179   return _gtk_tree_view_column_is_blank_at_pos (real_column,
14180                                                 &cell_area,
14181                                                 &background_area,
14182                                                 x, y);
14183 }
14184
14185 static void
14186 unset_reorderable (GtkTreeView *tree_view)
14187 {
14188   if (tree_view->priv->reorderable)
14189     {
14190       tree_view->priv->reorderable = FALSE;
14191       g_object_notify (G_OBJECT (tree_view), "reorderable");
14192     }
14193 }
14194
14195 /**
14196  * gtk_tree_view_enable_model_drag_source:
14197  * @tree_view: a #GtkTreeView
14198  * @start_button_mask: Mask of allowed buttons to start drag
14199  * @targets: (array length=n_targets): the table of targets that the drag will support
14200  * @n_targets: the number of items in @targets
14201  * @actions: the bitmask of possible actions for a drag from this
14202  *    widget
14203  *
14204  * Turns @tree_view into a drag source for automatic DND. Calling this
14205  * method sets #GtkTreeView:reorderable to %FALSE.
14206  **/
14207 void
14208 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
14209                                         GdkModifierType           start_button_mask,
14210                                         const GtkTargetEntry     *targets,
14211                                         gint                      n_targets,
14212                                         GdkDragAction             actions)
14213 {
14214   TreeViewDragInfo *di;
14215
14216   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14217
14218   gtk_drag_source_set (GTK_WIDGET (tree_view),
14219                        0,
14220                        targets,
14221                        n_targets,
14222                        actions);
14223
14224   di = ensure_info (tree_view);
14225
14226   di->start_button_mask = start_button_mask;
14227   di->source_actions = actions;
14228   di->source_set = TRUE;
14229
14230   unset_reorderable (tree_view);
14231 }
14232
14233 /**
14234  * gtk_tree_view_enable_model_drag_dest:
14235  * @tree_view: a #GtkTreeView
14236  * @targets: (array length=n_targets): the table of targets that
14237  *           the drag will support
14238  * @n_targets: the number of items in @targets
14239  * @actions: the bitmask of possible actions for a drag from this
14240  *    widget
14241  *
14242  * Turns @tree_view into a drop destination for automatic DND. Calling
14243  * this method sets #GtkTreeView:reorderable to %FALSE.
14244  **/
14245 void
14246 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
14247                                       const GtkTargetEntry     *targets,
14248                                       gint                      n_targets,
14249                                       GdkDragAction             actions)
14250 {
14251   TreeViewDragInfo *di;
14252
14253   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14254
14255   gtk_drag_dest_set (GTK_WIDGET (tree_view),
14256                      0,
14257                      targets,
14258                      n_targets,
14259                      actions);
14260
14261   di = ensure_info (tree_view);
14262   di->dest_set = TRUE;
14263
14264   unset_reorderable (tree_view);
14265 }
14266
14267 /**
14268  * gtk_tree_view_unset_rows_drag_source:
14269  * @tree_view: a #GtkTreeView
14270  *
14271  * Undoes the effect of
14272  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
14273  * #GtkTreeView:reorderable to %FALSE.
14274  **/
14275 void
14276 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
14277 {
14278   TreeViewDragInfo *di;
14279
14280   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14281
14282   di = get_info (tree_view);
14283
14284   if (di)
14285     {
14286       if (di->source_set)
14287         {
14288           gtk_drag_source_unset (GTK_WIDGET (tree_view));
14289           di->source_set = FALSE;
14290         }
14291
14292       if (!di->dest_set && !di->source_set)
14293         remove_info (tree_view);
14294     }
14295
14296   unset_reorderable (tree_view);
14297 }
14298
14299 /**
14300  * gtk_tree_view_unset_rows_drag_dest:
14301  * @tree_view: a #GtkTreeView
14302  *
14303  * Undoes the effect of
14304  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
14305  * #GtkTreeView:reorderable to %FALSE.
14306  **/
14307 void
14308 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
14309 {
14310   TreeViewDragInfo *di;
14311
14312   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14313
14314   di = get_info (tree_view);
14315
14316   if (di)
14317     {
14318       if (di->dest_set)
14319         {
14320           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
14321           di->dest_set = FALSE;
14322         }
14323
14324       if (!di->dest_set && !di->source_set)
14325         remove_info (tree_view);
14326     }
14327
14328   unset_reorderable (tree_view);
14329 }
14330
14331 /**
14332  * gtk_tree_view_set_drag_dest_row:
14333  * @tree_view: a #GtkTreeView
14334  * @path: (allow-none): The path of the row to highlight, or %NULL
14335  * @pos: Specifies whether to drop before, after or into the row
14336  *
14337  * Sets the row that is highlighted for feedback.
14338  * If @path is %NULL, an existing highlight is removed.
14339  */
14340 void
14341 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
14342                                  GtkTreePath            *path,
14343                                  GtkTreeViewDropPosition pos)
14344 {
14345   GtkTreePath *current_dest;
14346
14347   /* Note; this function is exported to allow a custom DND
14348    * implementation, so it can't touch TreeViewDragInfo
14349    */
14350
14351   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14352
14353   current_dest = NULL;
14354
14355   if (tree_view->priv->drag_dest_row)
14356     {
14357       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14358       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
14359     }
14360
14361   /* special case a drop on an empty model */
14362   tree_view->priv->empty_view_drop = 0;
14363
14364   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
14365       && gtk_tree_path_get_depth (path) == 1
14366       && gtk_tree_path_get_indices (path)[0] == 0)
14367     {
14368       gint n_children;
14369
14370       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
14371                                                    NULL);
14372
14373       if (!n_children)
14374         tree_view->priv->empty_view_drop = 1;
14375     }
14376
14377   tree_view->priv->drag_dest_pos = pos;
14378
14379   if (path)
14380     {
14381       tree_view->priv->drag_dest_row =
14382         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
14383       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
14384     }
14385   else
14386     tree_view->priv->drag_dest_row = NULL;
14387
14388   if (current_dest)
14389     {
14390       GtkRBTree *tree, *new_tree;
14391       GtkRBNode *node, *new_node;
14392
14393       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
14394       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
14395
14396       if (tree && node)
14397         {
14398           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
14399           if (new_tree && new_node)
14400             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14401
14402           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
14403           if (new_tree && new_node)
14404             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14405         }
14406       gtk_tree_path_free (current_dest);
14407     }
14408 }
14409
14410 /**
14411  * gtk_tree_view_get_drag_dest_row:
14412  * @tree_view: a #GtkTreeView
14413  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14414  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14415  *
14416  * Gets information about the row that is highlighted for feedback.
14417  **/
14418 void
14419 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
14420                                  GtkTreePath             **path,
14421                                  GtkTreeViewDropPosition  *pos)
14422 {
14423   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14424
14425   if (path)
14426     {
14427       if (tree_view->priv->drag_dest_row)
14428         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14429       else
14430         {
14431           if (tree_view->priv->empty_view_drop)
14432             *path = gtk_tree_path_new_from_indices (0, -1);
14433           else
14434             *path = NULL;
14435         }
14436     }
14437
14438   if (pos)
14439     *pos = tree_view->priv->drag_dest_pos;
14440 }
14441
14442 /**
14443  * gtk_tree_view_get_dest_row_at_pos:
14444  * @tree_view: a #GtkTreeView
14445  * @drag_x: the position to determine the destination row for
14446  * @drag_y: the position to determine the destination row for
14447  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14448  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14449  *
14450  * Determines the destination row for a given position.  @drag_x and
14451  * @drag_y are expected to be in widget coordinates.  This function is only
14452  * meaningful if @tree_view is realized.  Therefore this function will always
14453  * return %FALSE if @tree_view is not realized or does not have a model.
14454  *
14455  * Return value: whether there is a row at the given position, %TRUE if this
14456  * is indeed the case.
14457  **/
14458 gboolean
14459 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
14460                                    gint                     drag_x,
14461                                    gint                     drag_y,
14462                                    GtkTreePath            **path,
14463                                    GtkTreeViewDropPosition *pos)
14464 {
14465   gint cell_y;
14466   gint bin_x, bin_y;
14467   gdouble offset_into_row;
14468   gdouble third;
14469   GdkRectangle cell;
14470   GtkTreeViewColumn *column = NULL;
14471   GtkTreePath *tmp_path = NULL;
14472
14473   /* Note; this function is exported to allow a custom DND
14474    * implementation, so it can't touch TreeViewDragInfo
14475    */
14476
14477   g_return_val_if_fail (tree_view != NULL, FALSE);
14478   g_return_val_if_fail (drag_x >= 0, FALSE);
14479   g_return_val_if_fail (drag_y >= 0, FALSE);
14480
14481   if (path)
14482     *path = NULL;
14483
14484   if (tree_view->priv->bin_window == NULL)
14485     return FALSE;
14486
14487   if (tree_view->priv->tree == NULL)
14488     return FALSE;
14489
14490   /* If in the top third of a row, we drop before that row; if
14491    * in the bottom third, drop after that row; if in the middle,
14492    * and the row has children, drop into the row.
14493    */
14494   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
14495                                                      &bin_x, &bin_y);
14496
14497   if (!gtk_tree_view_get_path_at_pos (tree_view,
14498                                       bin_x,
14499                                       bin_y,
14500                                       &tmp_path,
14501                                       &column,
14502                                       NULL,
14503                                       &cell_y))
14504     return FALSE;
14505
14506   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
14507                                      &cell);
14508
14509   offset_into_row = cell_y;
14510
14511   if (path)
14512     *path = tmp_path;
14513   else
14514     gtk_tree_path_free (tmp_path);
14515
14516   tmp_path = NULL;
14517
14518   third = cell.height / 3.0;
14519
14520   if (pos)
14521     {
14522       if (offset_into_row < third)
14523         {
14524           *pos = GTK_TREE_VIEW_DROP_BEFORE;
14525         }
14526       else if (offset_into_row < (cell.height / 2.0))
14527         {
14528           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
14529         }
14530       else if (offset_into_row < third * 2.0)
14531         {
14532           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
14533         }
14534       else
14535         {
14536           *pos = GTK_TREE_VIEW_DROP_AFTER;
14537         }
14538     }
14539
14540   return TRUE;
14541 }
14542
14543
14544
14545 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
14546 /**
14547  * gtk_tree_view_create_row_drag_icon:
14548  * @tree_view: a #GtkTreeView
14549  * @path: a #GtkTreePath in @tree_view
14550  *
14551  * Creates a #cairo_surface_t representation of the row at @path.
14552  * This image is used for a drag icon.
14553  *
14554  * Return value: (transfer full): a newly-allocated surface of the drag icon.
14555  **/
14556 cairo_surface_t *
14557 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
14558                                     GtkTreePath  *path)
14559 {
14560   GtkTreeIter   iter;
14561   GtkRBTree    *tree;
14562   GtkRBNode    *node;
14563   GtkStyleContext *context;
14564   gint cell_offset;
14565   GList *list;
14566   GdkRectangle background_area;
14567   GtkWidget *widget;
14568   gint depth;
14569   /* start drawing inside the black outline */
14570   gint x = 1, y = 1;
14571   cairo_surface_t *surface;
14572   gint bin_window_width;
14573   gboolean is_separator = FALSE;
14574   gboolean rtl, allow_rules;
14575   cairo_t *cr;
14576
14577   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14578   g_return_val_if_fail (path != NULL, NULL);
14579
14580   widget = GTK_WIDGET (tree_view);
14581
14582   if (!gtk_widget_get_realized (widget))
14583     return NULL;
14584
14585   depth = gtk_tree_path_get_depth (path);
14586
14587   _gtk_tree_view_find_node (tree_view,
14588                             path,
14589                             &tree,
14590                             &node);
14591
14592   if (tree == NULL)
14593     return NULL;
14594
14595   if (!gtk_tree_model_get_iter (tree_view->priv->model,
14596                                 &iter,
14597                                 path))
14598     return NULL;
14599
14600   context = gtk_widget_get_style_context (widget);
14601
14602   gtk_style_context_save (context);
14603
14604   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
14605   gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0);
14606
14607   gtk_widget_style_get (widget,
14608                         "allow-rules", &allow_rules,
14609                         NULL);
14610
14611   if (allow_rules && tree_view->priv->has_rules)
14612     {
14613       GtkRegionFlags row_flags;
14614
14615       if ((_gtk_rbtree_node_get_index (tree, node) % 2))
14616         row_flags = GTK_REGION_ODD;
14617       else
14618         row_flags = GTK_REGION_EVEN;
14619
14620       gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
14621     }
14622
14623   is_separator = row_is_separator (tree_view, &iter, NULL);
14624
14625   cell_offset = x;
14626
14627   background_area.y = y;
14628   background_area.height = gtk_tree_view_get_row_height (tree_view, node);
14629
14630   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
14631
14632   surface = gdk_window_create_similar_surface (tree_view->priv->bin_window,
14633                                                CAIRO_CONTENT_COLOR,
14634                                                bin_window_width + 2,
14635                                                background_area.height + 2);
14636
14637   cr = cairo_create (surface);
14638
14639   gtk_render_background (context, cr, 0, 0,
14640                          bin_window_width + 2,
14641                          background_area.height + 2);
14642
14643   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
14644
14645   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
14646       list;
14647       list = (rtl ? list->prev : list->next))
14648     {
14649       GtkTreeViewColumn *column = list->data;
14650       GdkRectangle cell_area;
14651       gint vertical_separator;
14652
14653       if (!gtk_tree_view_column_get_visible (column))
14654         continue;
14655
14656       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
14657                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14658                                                node->children?TRUE:FALSE);
14659
14660       background_area.x = cell_offset;
14661       background_area.width = gtk_tree_view_column_get_width (column);
14662
14663       gtk_widget_style_get (widget,
14664                             "vertical-separator", &vertical_separator,
14665                             NULL);
14666
14667       cell_area = background_area;
14668
14669       cell_area.y += vertical_separator / 2;
14670       cell_area.height -= vertical_separator;
14671
14672       if (gtk_tree_view_is_expander_column (tree_view, column))
14673         {
14674           if (!rtl)
14675             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
14676           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
14677
14678           if (gtk_tree_view_draw_expanders (tree_view))
14679             {
14680               if (!rtl)
14681                 cell_area.x += depth * tree_view->priv->expander_size;
14682               cell_area.width -= depth * tree_view->priv->expander_size;
14683             }
14684         }
14685
14686       if (gtk_tree_view_column_cell_is_visible (column))
14687         {
14688           if (is_separator)
14689             {
14690               gtk_style_context_save (context);
14691               gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
14692
14693               gtk_render_line (context, cr,
14694                                cell_area.x,
14695                                cell_area.y + cell_area.height / 2,
14696                                cell_area.x + cell_area.width,
14697                                cell_area.y + cell_area.height / 2);
14698
14699               gtk_style_context_restore (context);
14700             }
14701           else
14702             {
14703               _gtk_tree_view_column_cell_render (column,
14704                                                  cr,
14705                                                  &background_area,
14706                                                  &cell_area,
14707                                                  0, FALSE);
14708             }
14709         }
14710       cell_offset += gtk_tree_view_column_get_width (column);
14711     }
14712
14713   cairo_set_source_rgb (cr, 0, 0, 0);
14714   cairo_rectangle (cr,
14715                    0.5, 0.5,
14716                    bin_window_width + 1,
14717                    background_area.height + 1);
14718   cairo_set_line_width (cr, 1.0);
14719   cairo_stroke (cr);
14720
14721   cairo_destroy (cr);
14722
14723   cairo_surface_set_device_offset (surface, 2, 2);
14724
14725   gtk_style_context_restore (context);
14726
14727   return surface;
14728 }
14729
14730
14731 /**
14732  * gtk_tree_view_set_destroy_count_func:
14733  * @tree_view: A #GtkTreeView
14734  * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
14735  * @data: (allow-none): User data to be passed to @func, or %NULL
14736  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14737  *
14738  * This function should almost never be used.  It is meant for private use by
14739  * ATK for determining the number of visible children that are removed when the
14740  * user collapses a row, or a row is deleted.
14741  *
14742  * Deprecated: 3.4: Accessibility does not need the function anymore.
14743  **/
14744 void
14745 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
14746                                       GtkTreeDestroyCountFunc  func,
14747                                       gpointer                 data,
14748                                       GDestroyNotify           destroy)
14749 {
14750   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14751
14752   if (tree_view->priv->destroy_count_destroy)
14753     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
14754
14755   tree_view->priv->destroy_count_func = func;
14756   tree_view->priv->destroy_count_data = data;
14757   tree_view->priv->destroy_count_destroy = destroy;
14758 }
14759
14760
14761 /*
14762  * Interactive search
14763  */
14764
14765 /**
14766  * gtk_tree_view_set_enable_search:
14767  * @tree_view: A #GtkTreeView
14768  * @enable_search: %TRUE, if the user can search interactively
14769  *
14770  * If @enable_search is set, then the user can type in text to search through
14771  * the tree interactively (this is sometimes called "typeahead find").
14772  *
14773  * Note that even if this is %FALSE, the user can still initiate a search
14774  * using the "start-interactive-search" key binding.
14775  */
14776 void
14777 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
14778                                  gboolean     enable_search)
14779 {
14780   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14781
14782   enable_search = !!enable_search;
14783
14784   if (tree_view->priv->enable_search != enable_search)
14785     {
14786        tree_view->priv->enable_search = enable_search;
14787        g_object_notify (G_OBJECT (tree_view), "enable-search");
14788     }
14789 }
14790
14791 /**
14792  * gtk_tree_view_get_enable_search:
14793  * @tree_view: A #GtkTreeView
14794  *
14795  * Returns whether or not the tree allows to start interactive searching
14796  * by typing in text.
14797  *
14798  * Return value: whether or not to let the user search interactively
14799  */
14800 gboolean
14801 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
14802 {
14803   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14804
14805   return tree_view->priv->enable_search;
14806 }
14807
14808
14809 /**
14810  * gtk_tree_view_get_search_column:
14811  * @tree_view: A #GtkTreeView
14812  *
14813  * Gets the column searched on by the interactive search code.
14814  *
14815  * Return value: the column the interactive search code searches in.
14816  */
14817 gint
14818 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
14819 {
14820   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
14821
14822   return (tree_view->priv->search_column);
14823 }
14824
14825 /**
14826  * gtk_tree_view_set_search_column:
14827  * @tree_view: A #GtkTreeView
14828  * @column: the column of the model to search in, or -1 to disable searching
14829  *
14830  * Sets @column as the column where the interactive search code should
14831  * search in for the current model.
14832  *
14833  * If the search column is set, users can use the "start-interactive-search"
14834  * key binding to bring up search popup. The enable-search property controls
14835  * whether simply typing text will also start an interactive search.
14836  *
14837  * Note that @column refers to a column of the current model. The search
14838  * column is reset to -1 when the model is changed.
14839  */
14840 void
14841 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
14842                                  gint         column)
14843 {
14844   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14845   g_return_if_fail (column >= -1);
14846
14847   if (tree_view->priv->search_column == column)
14848     return;
14849
14850   tree_view->priv->search_column = column;
14851   g_object_notify (G_OBJECT (tree_view), "search-column");
14852 }
14853
14854 /**
14855  * gtk_tree_view_get_search_equal_func: (skip)
14856  * @tree_view: A #GtkTreeView
14857  *
14858  * Returns the compare function currently in use.
14859  *
14860  * Return value: the currently used compare function for the search code.
14861  */
14862
14863 GtkTreeViewSearchEqualFunc
14864 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
14865 {
14866   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14867
14868   return tree_view->priv->search_equal_func;
14869 }
14870
14871 /**
14872  * gtk_tree_view_set_search_equal_func:
14873  * @tree_view: A #GtkTreeView
14874  * @search_equal_func: the compare function to use during the search
14875  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
14876  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
14877  *
14878  * Sets the compare function for the interactive search capabilities; note
14879  * that somewhat like strcmp() returning 0 for equality
14880  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
14881  **/
14882 void
14883 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14884                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14885                                      gpointer                    search_user_data,
14886                                      GDestroyNotify              search_destroy)
14887 {
14888   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14889   g_return_if_fail (search_equal_func != NULL);
14890
14891   if (tree_view->priv->search_destroy)
14892     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14893
14894   tree_view->priv->search_equal_func = search_equal_func;
14895   tree_view->priv->search_user_data = search_user_data;
14896   tree_view->priv->search_destroy = search_destroy;
14897   if (tree_view->priv->search_equal_func == NULL)
14898     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14899 }
14900
14901 /**
14902  * gtk_tree_view_get_search_entry:
14903  * @tree_view: A #GtkTreeView
14904  *
14905  * Returns the #GtkEntry which is currently in use as interactive search
14906  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14907  * will be returned.
14908  *
14909  * Return value: (transfer none): the entry currently in use as search entry.
14910  *
14911  * Since: 2.10
14912  */
14913 GtkEntry *
14914 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14915 {
14916   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14917
14918   if (tree_view->priv->search_custom_entry_set)
14919     return GTK_ENTRY (tree_view->priv->search_entry);
14920
14921   return NULL;
14922 }
14923
14924 /**
14925  * gtk_tree_view_set_search_entry:
14926  * @tree_view: A #GtkTreeView
14927  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
14928  *
14929  * Sets the entry which the interactive search code will use for this
14930  * @tree_view.  This is useful when you want to provide a search entry
14931  * in our interface at all time at a fixed position.  Passing %NULL for
14932  * @entry will make the interactive search code use the built-in popup
14933  * entry again.
14934  *
14935  * Since: 2.10
14936  */
14937 void
14938 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14939                                 GtkEntry    *entry)
14940 {
14941   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14942   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14943
14944   if (tree_view->priv->search_custom_entry_set)
14945     {
14946       if (tree_view->priv->search_entry_changed_id)
14947         {
14948           g_signal_handler_disconnect (tree_view->priv->search_entry,
14949                                        tree_view->priv->search_entry_changed_id);
14950           tree_view->priv->search_entry_changed_id = 0;
14951         }
14952       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14953                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14954                                             tree_view);
14955
14956       g_object_unref (tree_view->priv->search_entry);
14957     }
14958   else if (tree_view->priv->search_window)
14959     {
14960       gtk_widget_destroy (tree_view->priv->search_window);
14961
14962       tree_view->priv->search_window = NULL;
14963     }
14964
14965   if (entry)
14966     {
14967       tree_view->priv->search_entry = g_object_ref (entry);
14968       tree_view->priv->search_custom_entry_set = TRUE;
14969
14970       if (tree_view->priv->search_entry_changed_id == 0)
14971         {
14972           tree_view->priv->search_entry_changed_id =
14973             g_signal_connect (tree_view->priv->search_entry, "changed",
14974                               G_CALLBACK (gtk_tree_view_search_init),
14975                               tree_view);
14976         }
14977
14978         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14979                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14980                           tree_view);
14981
14982         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14983     }
14984   else
14985     {
14986       tree_view->priv->search_entry = NULL;
14987       tree_view->priv->search_custom_entry_set = FALSE;
14988     }
14989 }
14990
14991 /**
14992  * gtk_tree_view_set_search_position_func:
14993  * @tree_view: A #GtkTreeView
14994  * @func: (allow-none): the function to use to position the search dialog, or %NULL
14995  *    to use the default search position function
14996  * @data: (allow-none): user data to pass to @func, or %NULL
14997  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14998  *
14999  * Sets the function to use when positioning the search dialog.
15000  *
15001  * Since: 2.10
15002  **/
15003 void
15004 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
15005                                         GtkTreeViewSearchPositionFunc  func,
15006                                         gpointer                       user_data,
15007                                         GDestroyNotify                 destroy)
15008 {
15009   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15010
15011   if (tree_view->priv->search_position_destroy)
15012     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
15013
15014   tree_view->priv->search_position_func = func;
15015   tree_view->priv->search_position_user_data = user_data;
15016   tree_view->priv->search_position_destroy = destroy;
15017   if (tree_view->priv->search_position_func == NULL)
15018     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
15019 }
15020
15021 /**
15022  * gtk_tree_view_get_search_position_func: (skip)
15023  * @tree_view: A #GtkTreeView
15024  *
15025  * Returns the positioning function currently in use.
15026  *
15027  * Return value: the currently used function for positioning the search dialog.
15028  *
15029  * Since: 2.10
15030  */
15031 GtkTreeViewSearchPositionFunc
15032 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
15033 {
15034   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15035
15036   return tree_view->priv->search_position_func;
15037 }
15038
15039
15040 static void
15041 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
15042                                   GtkTreeView *tree_view,
15043                                   GdkDevice   *device)
15044 {
15045   if (tree_view->priv->disable_popdown)
15046     return;
15047
15048   if (tree_view->priv->search_entry_changed_id)
15049     {
15050       g_signal_handler_disconnect (tree_view->priv->search_entry,
15051                                    tree_view->priv->search_entry_changed_id);
15052       tree_view->priv->search_entry_changed_id = 0;
15053     }
15054   if (tree_view->priv->typeselect_flush_timeout)
15055     {
15056       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15057       tree_view->priv->typeselect_flush_timeout = 0;
15058     }
15059
15060   if (gtk_widget_get_visible (search_dialog))
15061     {
15062       /* send focus-in event */
15063       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
15064       gtk_widget_hide (search_dialog);
15065       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
15066       send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
15067     }
15068 }
15069
15070 static void
15071 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
15072                                     GtkWidget   *search_dialog,
15073                                     gpointer     user_data)
15074 {
15075   gint x, y;
15076   gint tree_x, tree_y;
15077   gint tree_width, tree_height;
15078   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
15079   GdkScreen *screen = gdk_window_get_screen (tree_window);
15080   GtkRequisition requisition;
15081   gint monitor_num;
15082   GdkRectangle monitor;
15083
15084   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
15085   gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
15086
15087   gtk_widget_realize (search_dialog);
15088
15089   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
15090   tree_width = gdk_window_get_width (tree_window);
15091   tree_height = gdk_window_get_height (tree_window);
15092   gtk_widget_get_preferred_size (search_dialog, &requisition, NULL);
15093
15094   if (tree_x + tree_width > gdk_screen_get_width (screen))
15095     x = gdk_screen_get_width (screen) - requisition.width;
15096   else if (tree_x + tree_width - requisition.width < 0)
15097     x = 0;
15098   else
15099     x = tree_x + tree_width - requisition.width;
15100
15101   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
15102     y = gdk_screen_get_height (screen) - requisition.height;
15103   else if (tree_y + tree_height < 0) /* isn't really possible ... */
15104     y = 0;
15105   else
15106     y = tree_y + tree_height;
15107
15108   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
15109 }
15110
15111 static void
15112 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
15113                                       GtkMenu  *menu,
15114                                       gpointer  data)
15115 {
15116   GtkTreeView *tree_view = (GtkTreeView *)data;
15117
15118   tree_view->priv->disable_popdown = 1;
15119   g_signal_connect (menu, "hide",
15120                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
15121 }
15122
15123 /* Because we're visible but offscreen, we just set a flag in the preedit
15124  * callback.
15125  */
15126 static void
15127 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
15128                                       GtkTreeView  *tree_view)
15129 {
15130   tree_view->priv->imcontext_changed = 1;
15131   if (tree_view->priv->typeselect_flush_timeout)
15132     {
15133       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15134       tree_view->priv->typeselect_flush_timeout =
15135         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15136                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15137                        tree_view);
15138     }
15139
15140 }
15141
15142 static void
15143 gtk_tree_view_search_activate (GtkEntry    *entry,
15144                                GtkTreeView *tree_view)
15145 {
15146   GtkTreePath *path;
15147
15148   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
15149                                     tree_view,
15150                                     gtk_get_current_event_device ());
15151
15152   /* If we have a row selected and it's the cursor row, we activate
15153    * the row XXX */
15154   if (tree_view->priv->cursor_node &&
15155       GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
15156     {
15157       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
15158                                              tree_view->priv->cursor_node);
15159
15160       gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
15161
15162       gtk_tree_path_free (path);
15163     }
15164 }
15165
15166 static gboolean
15167 gtk_tree_view_real_search_enable_popdown (gpointer data)
15168 {
15169   GtkTreeView *tree_view = (GtkTreeView *)data;
15170
15171   tree_view->priv->disable_popdown = 0;
15172
15173   return FALSE;
15174 }
15175
15176 static void
15177 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
15178                                      gpointer   data)
15179 {
15180   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
15181 }
15182
15183 static gboolean
15184 gtk_tree_view_search_delete_event (GtkWidget *widget,
15185                                    GdkEventAny *event,
15186                                    GtkTreeView *tree_view)
15187 {
15188   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15189
15190   gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
15191
15192   return TRUE;
15193 }
15194
15195 static gboolean
15196 gtk_tree_view_search_button_press_event (GtkWidget *widget,
15197                                          GdkEventButton *event,
15198                                          GtkTreeView *tree_view)
15199 {
15200   GdkDevice *keyb_device;
15201
15202   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15203
15204   keyb_device = gdk_device_get_associated_device (event->device);
15205   gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
15206
15207   if (event->window == tree_view->priv->bin_window)
15208     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
15209
15210   return TRUE;
15211 }
15212
15213 static gboolean
15214 gtk_tree_view_search_scroll_event (GtkWidget *widget,
15215                                    GdkEventScroll *event,
15216                                    GtkTreeView *tree_view)
15217 {
15218   gboolean retval = FALSE;
15219
15220   if (event->direction == GDK_SCROLL_UP)
15221     {
15222       gtk_tree_view_search_move (widget, tree_view, TRUE);
15223       retval = TRUE;
15224     }
15225   else if (event->direction == GDK_SCROLL_DOWN)
15226     {
15227       gtk_tree_view_search_move (widget, tree_view, FALSE);
15228       retval = TRUE;
15229     }
15230
15231   /* renew the flush timeout */
15232   if (retval && tree_view->priv->typeselect_flush_timeout
15233       && !tree_view->priv->search_custom_entry_set)
15234     {
15235       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15236       tree_view->priv->typeselect_flush_timeout =
15237         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15238                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15239                        tree_view);
15240     }
15241
15242   return retval;
15243 }
15244
15245 static gboolean
15246 gtk_tree_view_search_key_press_event (GtkWidget *widget,
15247                                       GdkEventKey *event,
15248                                       GtkTreeView *tree_view)
15249 {
15250   GdkModifierType default_accel;
15251   gboolean        retval = FALSE;
15252
15253   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15254   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15255
15256   /* close window and cancel the search */
15257   if (!tree_view->priv->search_custom_entry_set
15258       && (event->keyval == GDK_KEY_Escape ||
15259           event->keyval == GDK_KEY_Tab ||
15260             event->keyval == GDK_KEY_KP_Tab ||
15261             event->keyval == GDK_KEY_ISO_Left_Tab))
15262     {
15263       gtk_tree_view_search_dialog_hide (widget, tree_view,
15264                                         gdk_event_get_device ((GdkEvent *) event));
15265       return TRUE;
15266     }
15267
15268   default_accel = gtk_widget_get_modifier_mask (widget,
15269                                                 GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
15270
15271   /* select previous matching iter */
15272   if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
15273     {
15274       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15275         gtk_widget_error_bell (widget);
15276
15277       retval = TRUE;
15278     }
15279
15280   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == (default_accel | GDK_SHIFT_MASK))
15281       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15282     {
15283       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15284         gtk_widget_error_bell (widget);
15285
15286       retval = TRUE;
15287     }
15288
15289   /* select next matching iter */
15290   if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
15291     {
15292       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15293         gtk_widget_error_bell (widget);
15294
15295       retval = TRUE;
15296     }
15297
15298   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == default_accel)
15299       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15300     {
15301       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15302         gtk_widget_error_bell (widget);
15303
15304       retval = TRUE;
15305     }
15306
15307   /* renew the flush timeout */
15308   if (retval && tree_view->priv->typeselect_flush_timeout
15309       && !tree_view->priv->search_custom_entry_set)
15310     {
15311       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15312       tree_view->priv->typeselect_flush_timeout =
15313         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15314                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15315                        tree_view);
15316     }
15317
15318   return retval;
15319 }
15320
15321 /*  this function returns FALSE if there is a search string but
15322  *  nothing was found, and TRUE otherwise.
15323  */
15324 static gboolean
15325 gtk_tree_view_search_move (GtkWidget   *window,
15326                            GtkTreeView *tree_view,
15327                            gboolean     up)
15328 {
15329   gboolean ret;
15330   gint len;
15331   gint count = 0;
15332   const gchar *text;
15333   GtkTreeIter iter;
15334   GtkTreeModel *model;
15335   GtkTreeSelection *selection;
15336
15337   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
15338
15339   g_return_val_if_fail (text != NULL, FALSE);
15340
15341   len = strlen (text);
15342
15343   if (up && tree_view->priv->selected_iter == 1)
15344     return strlen (text) < 1;
15345
15346   len = strlen (text);
15347
15348   if (len < 1)
15349     return TRUE;
15350
15351   model = gtk_tree_view_get_model (tree_view);
15352   selection = gtk_tree_view_get_selection (tree_view);
15353
15354   /* search */
15355   gtk_tree_selection_unselect_all (selection);
15356   if (!gtk_tree_model_get_iter_first (model, &iter))
15357     return TRUE;
15358
15359   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
15360                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
15361
15362   if (ret)
15363     {
15364       /* found */
15365       tree_view->priv->selected_iter += up?(-1):(1);
15366       return TRUE;
15367     }
15368   else
15369     {
15370       /* return to old iter */
15371       count = 0;
15372       gtk_tree_model_get_iter_first (model, &iter);
15373       gtk_tree_view_search_iter (model, selection,
15374                                  &iter, text,
15375                                  &count, tree_view->priv->selected_iter);
15376       return FALSE;
15377     }
15378 }
15379
15380 static gboolean
15381 gtk_tree_view_search_equal_func (GtkTreeModel *model,
15382                                  gint          column,
15383                                  const gchar  *key,
15384                                  GtkTreeIter  *iter,
15385                                  gpointer      search_data)
15386 {
15387   gboolean retval = TRUE;
15388   const gchar *str;
15389   gchar *normalized_string;
15390   gchar *normalized_key;
15391   gchar *case_normalized_string = NULL;
15392   gchar *case_normalized_key = NULL;
15393   GValue value = G_VALUE_INIT;
15394   GValue transformed = G_VALUE_INIT;
15395
15396   gtk_tree_model_get_value (model, iter, column, &value);
15397
15398   g_value_init (&transformed, G_TYPE_STRING);
15399
15400   if (!g_value_transform (&value, &transformed))
15401     {
15402       g_value_unset (&value);
15403       return TRUE;
15404     }
15405
15406   g_value_unset (&value);
15407
15408   str = g_value_get_string (&transformed);
15409   if (!str)
15410     {
15411       g_value_unset (&transformed);
15412       return TRUE;
15413     }
15414
15415   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
15416   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
15417
15418   if (normalized_string && normalized_key)
15419     {
15420       case_normalized_string = g_utf8_casefold (normalized_string, -1);
15421       case_normalized_key = g_utf8_casefold (normalized_key, -1);
15422
15423       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
15424         retval = FALSE;
15425     }
15426
15427   g_value_unset (&transformed);
15428   g_free (normalized_key);
15429   g_free (normalized_string);
15430   g_free (case_normalized_key);
15431   g_free (case_normalized_string);
15432
15433   return retval;
15434 }
15435
15436 static gboolean
15437 gtk_tree_view_search_iter (GtkTreeModel     *model,
15438                            GtkTreeSelection *selection,
15439                            GtkTreeIter      *iter,
15440                            const gchar      *text,
15441                            gint             *count,
15442                            gint              n)
15443 {
15444   GtkRBTree *tree = NULL;
15445   GtkRBNode *node = NULL;
15446   GtkTreePath *path;
15447
15448   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
15449
15450   path = gtk_tree_model_get_path (model, iter);
15451   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15452
15453   do
15454     {
15455       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
15456         {
15457           (*count)++;
15458           if (*count == n)
15459             {
15460               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
15461                                             TRUE, 0.5, 0.0);
15462               gtk_tree_selection_select_iter (selection, iter);
15463               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15464
15465               if (path)
15466                 gtk_tree_path_free (path);
15467
15468               return TRUE;
15469             }
15470         }
15471
15472       if (node->children)
15473         {
15474           gboolean has_child;
15475           GtkTreeIter tmp;
15476
15477           tree = node->children;
15478           node = _gtk_rbtree_first (tree);
15479
15480           tmp = *iter;
15481           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
15482           gtk_tree_path_down (path);
15483
15484           /* sanity check */
15485           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
15486         }
15487       else
15488         {
15489           gboolean done = FALSE;
15490
15491           do
15492             {
15493               node = _gtk_rbtree_next (tree, node);
15494
15495               if (node)
15496                 {
15497                   gboolean has_next;
15498
15499                   has_next = gtk_tree_model_iter_next (model, iter);
15500
15501                   done = TRUE;
15502                   gtk_tree_path_next (path);
15503
15504                   /* sanity check */
15505                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
15506                 }
15507               else
15508                 {
15509                   gboolean has_parent;
15510                   GtkTreeIter tmp_iter = *iter;
15511
15512                   node = tree->parent_node;
15513                   tree = tree->parent_tree;
15514
15515                   if (!tree)
15516                     {
15517                       if (path)
15518                         gtk_tree_path_free (path);
15519
15520                       /* we've run out of tree, done with this func */
15521                       return FALSE;
15522                     }
15523
15524                   has_parent = gtk_tree_model_iter_parent (model,
15525                                                            iter,
15526                                                            &tmp_iter);
15527                   gtk_tree_path_up (path);
15528
15529                   /* sanity check */
15530                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
15531                 }
15532             }
15533           while (!done);
15534         }
15535     }
15536   while (1);
15537
15538   return FALSE;
15539 }
15540
15541 static void
15542 gtk_tree_view_search_init (GtkWidget   *entry,
15543                            GtkTreeView *tree_view)
15544 {
15545   gint ret;
15546   gint count = 0;
15547   const gchar *text;
15548   GtkTreeIter iter;
15549   GtkTreeModel *model;
15550   GtkTreeSelection *selection;
15551
15552   g_return_if_fail (GTK_IS_ENTRY (entry));
15553   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15554
15555   text = gtk_entry_get_text (GTK_ENTRY (entry));
15556
15557   model = gtk_tree_view_get_model (tree_view);
15558   selection = gtk_tree_view_get_selection (tree_view);
15559
15560   /* search */
15561   gtk_tree_selection_unselect_all (selection);
15562   if (tree_view->priv->typeselect_flush_timeout
15563       && !tree_view->priv->search_custom_entry_set)
15564     {
15565       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15566       tree_view->priv->typeselect_flush_timeout =
15567         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15568                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15569                        tree_view);
15570     }
15571
15572   if (*text == '\0')
15573     return;
15574
15575   if (!gtk_tree_model_get_iter_first (model, &iter))
15576     return;
15577
15578   ret = gtk_tree_view_search_iter (model, selection,
15579                                    &iter, text,
15580                                    &count, 1);
15581
15582   if (ret)
15583     tree_view->priv->selected_iter = 1;
15584 }
15585
15586 void
15587 _gtk_tree_view_remove_editable (GtkTreeView       *tree_view,
15588                                 GtkTreeViewColumn *column,
15589                                 GtkCellEditable   *cell_editable)
15590 {
15591   if (tree_view->priv->edited_column == NULL)
15592     return;
15593
15594   g_return_if_fail (column == tree_view->priv->edited_column);
15595
15596   tree_view->priv->edited_column = NULL;
15597
15598   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
15599     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
15600
15601   gtk_container_remove (GTK_CONTAINER (tree_view),
15602                         GTK_WIDGET (cell_editable));
15603
15604   /* FIXME should only redraw a single node */
15605   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15606 }
15607
15608 static gboolean
15609 gtk_tree_view_start_editing (GtkTreeView *tree_view,
15610                              GtkTreePath *cursor_path,
15611                              gboolean     edit_only)
15612 {
15613   GtkTreeIter iter;
15614   GdkRectangle cell_area;
15615   GtkTreeViewColumn *focus_column;
15616   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
15617   gint retval = FALSE;
15618   GtkRBTree *cursor_tree;
15619   GtkRBNode *cursor_node;
15620
15621   g_assert (tree_view->priv->focus_column);
15622   focus_column = tree_view->priv->focus_column;
15623
15624   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
15625     return FALSE;
15626
15627   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
15628       cursor_node == NULL)
15629     return FALSE;
15630
15631   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
15632
15633   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
15634
15635   gtk_tree_view_column_cell_set_cell_data (focus_column,
15636                                            tree_view->priv->model,
15637                                            &iter,
15638                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
15639                                            cursor_node->children ? TRUE : FALSE);
15640   gtk_tree_view_get_cell_area (tree_view,
15641                                cursor_path,
15642                                focus_column,
15643                                &cell_area);
15644
15645   if (gtk_cell_area_activate (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (focus_column)),
15646                               _gtk_tree_view_column_get_context (focus_column),
15647                               GTK_WIDGET (tree_view),
15648                               &cell_area,
15649                               flags, edit_only))
15650     retval = TRUE;
15651
15652   return retval;
15653 }
15654
15655 void
15656 _gtk_tree_view_add_editable (GtkTreeView       *tree_view,
15657                              GtkTreeViewColumn *column,
15658                              GtkTreePath       *path,
15659                              GtkCellEditable   *cell_editable,
15660                              GdkRectangle      *cell_area)
15661 {
15662   gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
15663   GtkRequisition requisition;
15664
15665   tree_view->priv->edited_column = column;
15666
15667   gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15668   cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
15669
15670   gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
15671                                  &requisition, NULL);
15672
15673   tree_view->priv->draw_keyfocus = TRUE;
15674
15675   if (requisition.height < cell_area->height)
15676     {
15677       gint diff = cell_area->height - requisition.height;
15678       gtk_tree_view_put (tree_view,
15679                          GTK_WIDGET (cell_editable),
15680                          cell_area->x, cell_area->y + diff/2,
15681                          cell_area->width, requisition.height);
15682     }
15683   else
15684     {
15685       gtk_tree_view_put (tree_view,
15686                          GTK_WIDGET (cell_editable),
15687                          cell_area->x, cell_area->y,
15688                          cell_area->width, cell_area->height);
15689     }
15690 }
15691
15692 static void
15693 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
15694                             gboolean     cancel_editing)
15695 {
15696   GtkTreeViewColumn *column;
15697
15698   if (tree_view->priv->edited_column == NULL)
15699     return;
15700
15701   /*
15702    * This is very evil. We need to do this, because
15703    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
15704    * later on. If gtk_tree_view_row_changed notices
15705    * tree_view->priv->edited_column != NULL, it'll call
15706    * gtk_tree_view_stop_editing again. Bad things will happen then.
15707    *
15708    * Please read that again if you intend to modify anything here.
15709    */
15710
15711   column = tree_view->priv->edited_column;
15712   gtk_cell_area_stop_editing (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)), cancel_editing);
15713   tree_view->priv->edited_column = NULL;
15714 }
15715
15716
15717 /**
15718  * gtk_tree_view_set_hover_selection:
15719  * @tree_view: a #GtkTreeView
15720  * @hover: %TRUE to enable hover selection mode
15721  *
15722  * Enables or disables the hover selection mode of @tree_view.
15723  * Hover selection makes the selected row follow the pointer.
15724  * Currently, this works only for the selection modes
15725  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
15726  *
15727  * Since: 2.6
15728  **/
15729 void
15730 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
15731                                    gboolean     hover)
15732 {
15733   hover = hover != FALSE;
15734
15735   if (hover != tree_view->priv->hover_selection)
15736     {
15737       tree_view->priv->hover_selection = hover;
15738
15739       g_object_notify (G_OBJECT (tree_view), "hover-selection");
15740     }
15741 }
15742
15743 /**
15744  * gtk_tree_view_get_hover_selection:
15745  * @tree_view: a #GtkTreeView
15746  *
15747  * Returns whether hover selection mode is turned on for @tree_view.
15748  *
15749  * Return value: %TRUE if @tree_view is in hover selection mode
15750  *
15751  * Since: 2.6
15752  **/
15753 gboolean
15754 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
15755 {
15756   return tree_view->priv->hover_selection;
15757 }
15758
15759 /**
15760  * gtk_tree_view_set_hover_expand:
15761  * @tree_view: a #GtkTreeView
15762  * @expand: %TRUE to enable hover selection mode
15763  *
15764  * Enables or disables the hover expansion mode of @tree_view.
15765  * Hover expansion makes rows expand or collapse if the pointer
15766  * moves over them.
15767  *
15768  * Since: 2.6
15769  **/
15770 void
15771 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
15772                                 gboolean     expand)
15773 {
15774   expand = expand != FALSE;
15775
15776   if (expand != tree_view->priv->hover_expand)
15777     {
15778       tree_view->priv->hover_expand = expand;
15779
15780       g_object_notify (G_OBJECT (tree_view), "hover-expand");
15781     }
15782 }
15783
15784 /**
15785  * gtk_tree_view_get_hover_expand:
15786  * @tree_view: a #GtkTreeView
15787  *
15788  * Returns whether hover expansion mode is turned on for @tree_view.
15789  *
15790  * Return value: %TRUE if @tree_view is in hover expansion mode
15791  *
15792  * Since: 2.6
15793  **/
15794 gboolean
15795 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
15796 {
15797   return tree_view->priv->hover_expand;
15798 }
15799
15800 /**
15801  * gtk_tree_view_set_rubber_banding:
15802  * @tree_view: a #GtkTreeView
15803  * @enable: %TRUE to enable rubber banding
15804  *
15805  * Enables or disables rubber banding in @tree_view.  If the selection mode
15806  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
15807  * multiple rows by dragging the mouse.
15808  *
15809  * Since: 2.10
15810  **/
15811 void
15812 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
15813                                   gboolean     enable)
15814 {
15815   enable = enable != FALSE;
15816
15817   if (enable != tree_view->priv->rubber_banding_enable)
15818     {
15819       tree_view->priv->rubber_banding_enable = enable;
15820
15821       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
15822     }
15823 }
15824
15825 /**
15826  * gtk_tree_view_get_rubber_banding:
15827  * @tree_view: a #GtkTreeView
15828  *
15829  * Returns whether rubber banding is turned on for @tree_view.  If the
15830  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15831  * user to select multiple rows by dragging the mouse.
15832  *
15833  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15834  *
15835  * Since: 2.10
15836  **/
15837 gboolean
15838 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15839 {
15840   return tree_view->priv->rubber_banding_enable;
15841 }
15842
15843 /**
15844  * gtk_tree_view_is_rubber_banding_active:
15845  * @tree_view: a #GtkTreeView
15846  *
15847  * Returns whether a rubber banding operation is currently being done
15848  * in @tree_view.
15849  *
15850  * Return value: %TRUE if a rubber banding operation is currently being
15851  * done in @tree_view.
15852  *
15853  * Since: 2.12
15854  **/
15855 gboolean
15856 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15857 {
15858   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15859
15860   if (tree_view->priv->rubber_banding_enable
15861       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15862     return TRUE;
15863
15864   return FALSE;
15865 }
15866
15867 /**
15868  * gtk_tree_view_get_row_separator_func: (skip)
15869  * @tree_view: a #GtkTreeView
15870  *
15871  * Returns the current row separator function.
15872  *
15873  * Return value: the current row separator function.
15874  *
15875  * Since: 2.6
15876  **/
15877 GtkTreeViewRowSeparatorFunc
15878 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15879 {
15880   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15881
15882   return tree_view->priv->row_separator_func;
15883 }
15884
15885 /**
15886  * gtk_tree_view_set_row_separator_func:
15887  * @tree_view: a #GtkTreeView
15888  * @func: (allow-none): a #GtkTreeViewRowSeparatorFunc
15889  * @data: (allow-none): user data to pass to @func, or %NULL
15890  * @destroy: (allow-none): destroy notifier for @data, or %NULL
15891  *
15892  * Sets the row separator function, which is used to determine
15893  * whether a row should be drawn as a separator. If the row separator
15894  * function is %NULL, no separators are drawn. This is the default value.
15895  *
15896  * Since: 2.6
15897  **/
15898 void
15899 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15900                                       GtkTreeViewRowSeparatorFunc  func,
15901                                       gpointer                     data,
15902                                       GDestroyNotify               destroy)
15903 {
15904   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15905
15906   if (tree_view->priv->row_separator_destroy)
15907     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15908
15909   tree_view->priv->row_separator_func = func;
15910   tree_view->priv->row_separator_data = data;
15911   tree_view->priv->row_separator_destroy = destroy;
15912
15913   /* Have the tree recalculate heights */
15914   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15915   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15916 }
15917
15918
15919 static void
15920 gtk_tree_view_grab_notify (GtkWidget *widget,
15921                            gboolean   was_grabbed)
15922 {
15923   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15924
15925   tree_view->priv->in_grab = !was_grabbed;
15926
15927   if (!was_grabbed)
15928     {
15929       tree_view->priv->pressed_button = -1;
15930
15931       if (tree_view->priv->rubber_band_status)
15932         gtk_tree_view_stop_rubber_band (tree_view);
15933     }
15934 }
15935
15936 static void
15937 gtk_tree_view_state_flags_changed (GtkWidget     *widget,
15938                                    GtkStateFlags  previous_state)
15939 {
15940   if (gtk_widget_get_realized (widget))
15941     gtk_tree_view_ensure_background (GTK_TREE_VIEW (widget));
15942
15943   gtk_widget_queue_draw (widget);
15944 }
15945
15946 /**
15947  * gtk_tree_view_get_grid_lines:
15948  * @tree_view: a #GtkTreeView
15949  *
15950  * Returns which grid lines are enabled in @tree_view.
15951  *
15952  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15953  * are enabled.
15954  *
15955  * Since: 2.10
15956  */
15957 GtkTreeViewGridLines
15958 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15959 {
15960   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15961
15962   return tree_view->priv->grid_lines;
15963 }
15964
15965 /**
15966  * gtk_tree_view_set_grid_lines:
15967  * @tree_view: a #GtkTreeView
15968  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15969  * enable.
15970  *
15971  * Sets which grid lines to draw in @tree_view.
15972  *
15973  * Since: 2.10
15974  */
15975 void
15976 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15977                               GtkTreeViewGridLines   grid_lines)
15978 {
15979   GtkTreeViewPrivate *priv;
15980   GtkWidget *widget;
15981   GtkTreeViewGridLines old_grid_lines;
15982
15983   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15984
15985   priv = tree_view->priv;
15986   widget = GTK_WIDGET (tree_view);
15987
15988   old_grid_lines = priv->grid_lines;
15989   priv->grid_lines = grid_lines;
15990
15991   if (gtk_widget_get_realized (widget))
15992     {
15993       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15994           priv->grid_line_width)
15995         {
15996           priv->grid_line_width = 0;
15997         }
15998
15999       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
16000           !priv->grid_line_width)
16001         {
16002           gint8 *dash_list;
16003
16004           gtk_widget_style_get (widget,
16005                                 "grid-line-width", &priv->grid_line_width,
16006                                 "grid-line-pattern", (gchar *)&dash_list,
16007                                 NULL);
16008
16009           if (dash_list)
16010             {
16011               priv->grid_line_dashes[0] = dash_list[0];
16012               if (dash_list[0])
16013                 priv->grid_line_dashes[1] = dash_list[1];
16014
16015               g_free (dash_list);
16016             }
16017           else
16018             {
16019               priv->grid_line_dashes[0] = 1;
16020               priv->grid_line_dashes[1] = 1;
16021             }
16022         }
16023     }
16024
16025   if (old_grid_lines != grid_lines)
16026     {
16027       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16028
16029       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
16030     }
16031 }
16032
16033 /**
16034  * gtk_tree_view_get_enable_tree_lines:
16035  * @tree_view: a #GtkTreeView.
16036  *
16037  * Returns whether or not tree lines are drawn in @tree_view.
16038  *
16039  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
16040  * otherwise.
16041  *
16042  * Since: 2.10
16043  */
16044 gboolean
16045 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
16046 {
16047   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16048
16049   return tree_view->priv->tree_lines_enabled;
16050 }
16051
16052 /**
16053  * gtk_tree_view_set_enable_tree_lines:
16054  * @tree_view: a #GtkTreeView
16055  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
16056  *
16057  * Sets whether to draw lines interconnecting the expanders in @tree_view.
16058  * This does not have any visible effects for lists.
16059  *
16060  * Since: 2.10
16061  */
16062 void
16063 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
16064                                      gboolean     enabled)
16065 {
16066   GtkTreeViewPrivate *priv;
16067   GtkWidget *widget;
16068   gboolean was_enabled;
16069
16070   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16071
16072   enabled = enabled != FALSE;
16073
16074   priv = tree_view->priv;
16075   widget = GTK_WIDGET (tree_view);
16076
16077   was_enabled = priv->tree_lines_enabled;
16078
16079   priv->tree_lines_enabled = enabled;
16080
16081   if (gtk_widget_get_realized (widget))
16082     {
16083       if (!enabled && priv->tree_line_width)
16084         {
16085           priv->tree_line_width = 0;
16086         }
16087
16088       if (enabled && !priv->tree_line_width)
16089         {
16090           gint8 *dash_list;
16091           gtk_widget_style_get (widget,
16092                                 "tree-line-width", &priv->tree_line_width,
16093                                 "tree-line-pattern", (gchar *)&dash_list,
16094                                 NULL);
16095
16096           if (dash_list)
16097             {
16098               priv->tree_line_dashes[0] = dash_list[0];
16099               if (dash_list[0])
16100                 priv->tree_line_dashes[1] = dash_list[1];
16101
16102               g_free (dash_list);
16103             }
16104           else
16105             {
16106               priv->tree_line_dashes[0] = 1;
16107               priv->tree_line_dashes[1] = 1;
16108             }
16109         }
16110     }
16111
16112   if (was_enabled != enabled)
16113     {
16114       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16115
16116       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
16117     }
16118 }
16119
16120
16121 /**
16122  * gtk_tree_view_set_show_expanders:
16123  * @tree_view: a #GtkTreeView
16124  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
16125  *
16126  * Sets whether to draw and enable expanders and indent child rows in
16127  * @tree_view.  When disabled there will be no expanders visible in trees
16128  * and there will be no way to expand and collapse rows by default.  Also
16129  * note that hiding the expanders will disable the default indentation.  You
16130  * can set a custom indentation in this case using
16131  * gtk_tree_view_set_level_indentation().
16132  * This does not have any visible effects for lists.
16133  *
16134  * Since: 2.12
16135  */
16136 void
16137 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
16138                                   gboolean     enabled)
16139 {
16140   gboolean was_enabled;
16141
16142   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16143
16144   enabled = enabled != FALSE;
16145   was_enabled = tree_view->priv->show_expanders;
16146
16147   tree_view->priv->show_expanders = enabled == TRUE;
16148
16149   if (enabled != was_enabled)
16150     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16151 }
16152
16153 /**
16154  * gtk_tree_view_get_show_expanders:
16155  * @tree_view: a #GtkTreeView.
16156  *
16157  * Returns whether or not expanders are drawn in @tree_view.
16158  *
16159  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
16160  * otherwise.
16161  *
16162  * Since: 2.12
16163  */
16164 gboolean
16165 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
16166 {
16167   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16168
16169   return tree_view->priv->show_expanders;
16170 }
16171
16172 /**
16173  * gtk_tree_view_set_level_indentation:
16174  * @tree_view: a #GtkTreeView
16175  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
16176  *
16177  * Sets the amount of extra indentation for child levels to use in @tree_view
16178  * in addition to the default indentation.  The value should be specified in
16179  * pixels, a value of 0 disables this feature and in this case only the default
16180  * indentation will be used.
16181  * This does not have any visible effects for lists.
16182  *
16183  * Since: 2.12
16184  */
16185 void
16186 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
16187                                      gint         indentation)
16188 {
16189   tree_view->priv->level_indentation = indentation;
16190
16191   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16192 }
16193
16194 /**
16195  * gtk_tree_view_get_level_indentation:
16196  * @tree_view: a #GtkTreeView.
16197  *
16198  * Returns the amount, in pixels, of extra indentation for child levels
16199  * in @tree_view.
16200  *
16201  * Return value: the amount of extra indentation for child levels in
16202  * @tree_view.  A return value of 0 means that this feature is disabled.
16203  *
16204  * Since: 2.12
16205  */
16206 gint
16207 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
16208 {
16209   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16210
16211   return tree_view->priv->level_indentation;
16212 }
16213
16214 /**
16215  * gtk_tree_view_set_tooltip_row:
16216  * @tree_view: a #GtkTreeView
16217  * @tooltip: a #GtkTooltip
16218  * @path: a #GtkTreePath
16219  *
16220  * Sets the tip area of @tooltip to be the area covered by the row at @path.
16221  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16222  * See also gtk_tooltip_set_tip_area().
16223  *
16224  * Since: 2.12
16225  */
16226 void
16227 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
16228                                GtkTooltip  *tooltip,
16229                                GtkTreePath *path)
16230 {
16231   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16232   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16233
16234   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
16235 }
16236
16237 /**
16238  * gtk_tree_view_set_tooltip_cell:
16239  * @tree_view: a #GtkTreeView
16240  * @tooltip: a #GtkTooltip
16241  * @path: (allow-none): a #GtkTreePath or %NULL
16242  * @column: (allow-none): a #GtkTreeViewColumn or %NULL
16243  * @cell: (allow-none): a #GtkCellRenderer or %NULL
16244  *
16245  * Sets the tip area of @tooltip to the area @path, @column and @cell have
16246  * in common.  For example if @path is %NULL and @column is set, the tip
16247  * area will be set to the full area covered by @column.  See also
16248  * gtk_tooltip_set_tip_area().
16249  *
16250  * Note that if @path is not specified and @cell is set and part of a column
16251  * containing the expander, the tooltip might not show and hide at the correct
16252  * position.  In such cases @path must be set to the current node under the
16253  * mouse cursor for this function to operate correctly.
16254  *
16255  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16256  *
16257  * Since: 2.12
16258  */
16259 void
16260 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
16261                                 GtkTooltip        *tooltip,
16262                                 GtkTreePath       *path,
16263                                 GtkTreeViewColumn *column,
16264                                 GtkCellRenderer   *cell)
16265 {
16266   GtkAllocation allocation;
16267   GdkRectangle rect;
16268
16269   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16270   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16271   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
16272   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
16273
16274   /* Determine x values. */
16275   if (column && cell)
16276     {
16277       GdkRectangle tmp;
16278       gint start, width;
16279
16280       /* We always pass in path here, whether it is NULL or not.
16281        * For cells in expander columns path must be specified so that
16282        * we can correctly account for the indentation.  This also means
16283        * that the tooltip is constrained vertically by the "Determine y
16284        * values" code below; this is not a real problem since cells actually
16285        * don't stretch vertically in constrast to columns.
16286        */
16287       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
16288       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
16289
16290       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16291                                                          tmp.x + start, 0,
16292                                                          &rect.x, NULL);
16293       rect.width = width;
16294     }
16295   else if (column)
16296     {
16297       GdkRectangle tmp;
16298
16299       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
16300       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16301                                                          tmp.x, 0,
16302                                                          &rect.x, NULL);
16303       rect.width = tmp.width;
16304     }
16305   else
16306     {
16307       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
16308       rect.x = 0;
16309       rect.width = allocation.width;
16310     }
16311
16312   /* Determine y values. */
16313   if (path)
16314     {
16315       GdkRectangle tmp;
16316
16317       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
16318       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16319                                                          0, tmp.y,
16320                                                          NULL, &rect.y);
16321       rect.height = tmp.height;
16322     }
16323   else
16324     {
16325       rect.y = 0;
16326       rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
16327     }
16328
16329   gtk_tooltip_set_tip_area (tooltip, &rect);
16330 }
16331
16332 /**
16333  * gtk_tree_view_get_tooltip_context:
16334  * @tree_view: a #GtkTreeView
16335  * @x: (inout): the x coordinate (relative to widget coordinates)
16336  * @y: (inout): the y coordinate (relative to widget coordinates)
16337  * @keyboard_tip: whether this is a keyboard tooltip or not
16338  * @model: (out) (allow-none) (transfer none): a pointer to receive a
16339  *         #GtkTreeModel or %NULL
16340  * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
16341  * @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
16342  *
16343  * This function is supposed to be used in a #GtkWidget::query-tooltip
16344  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
16345  * which are received in the signal handler, should be passed to this
16346  * function without modification.
16347  *
16348  * The return value indicates whether there is a tree view row at the given
16349  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
16350  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
16351  * @model, @path and @iter which have been provided will be set to point to
16352  * that row and the corresponding model.  @x and @y will always be converted
16353  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
16354  *
16355  * Return value: whether or not the given tooltip context points to a row.
16356  *
16357  * Since: 2.12
16358  */
16359 gboolean
16360 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
16361                                    gint          *x,
16362                                    gint          *y,
16363                                    gboolean       keyboard_tip,
16364                                    GtkTreeModel **model,
16365                                    GtkTreePath  **path,
16366                                    GtkTreeIter   *iter)
16367 {
16368   GtkTreePath *tmppath = NULL;
16369
16370   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16371   g_return_val_if_fail (x != NULL, FALSE);
16372   g_return_val_if_fail (y != NULL, FALSE);
16373
16374   if (keyboard_tip)
16375     {
16376       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
16377
16378       if (!tmppath)
16379         return FALSE;
16380     }
16381   else
16382     {
16383       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
16384                                                          x, y);
16385
16386       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
16387                                           &tmppath, NULL, NULL, NULL))
16388         return FALSE;
16389     }
16390
16391   if (model)
16392     *model = gtk_tree_view_get_model (tree_view);
16393
16394   if (iter)
16395     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
16396                              iter, tmppath);
16397
16398   if (path)
16399     *path = tmppath;
16400   else
16401     gtk_tree_path_free (tmppath);
16402
16403   return TRUE;
16404 }
16405
16406 static gboolean
16407 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
16408                                     gint        x,
16409                                     gint        y,
16410                                     gboolean    keyboard_tip,
16411                                     GtkTooltip *tooltip,
16412                                     gpointer    data)
16413 {
16414   GValue value = G_VALUE_INIT;
16415   GValue transformed = G_VALUE_INIT;
16416   GtkTreeIter iter;
16417   GtkTreePath *path;
16418   GtkTreeModel *model;
16419   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
16420
16421   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
16422                                           &x, &y,
16423                                           keyboard_tip,
16424                                           &model, &path, &iter))
16425     return FALSE;
16426
16427   gtk_tree_model_get_value (model, &iter,
16428                             tree_view->priv->tooltip_column, &value);
16429
16430   g_value_init (&transformed, G_TYPE_STRING);
16431
16432   if (!g_value_transform (&value, &transformed))
16433     {
16434       g_value_unset (&value);
16435       gtk_tree_path_free (path);
16436
16437       return FALSE;
16438     }
16439
16440   g_value_unset (&value);
16441
16442   if (!g_value_get_string (&transformed))
16443     {
16444       g_value_unset (&transformed);
16445       gtk_tree_path_free (path);
16446
16447       return FALSE;
16448     }
16449
16450   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
16451   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
16452
16453   gtk_tree_path_free (path);
16454   g_value_unset (&transformed);
16455
16456   return TRUE;
16457 }
16458
16459 /**
16460  * gtk_tree_view_set_tooltip_column:
16461  * @tree_view: a #GtkTreeView
16462  * @column: an integer, which is a valid column number for @tree_view's model
16463  *
16464  * If you only plan to have simple (text-only) tooltips on full rows, you
16465  * can use this function to have #GtkTreeView handle these automatically
16466  * for you. @column should be set to the column in @tree_view's model
16467  * containing the tooltip texts, or -1 to disable this feature.
16468  *
16469  * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
16470  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
16471  *
16472  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
16473  * so &amp;, &lt;, etc have to be escaped in the text.
16474  *
16475  * Since: 2.12
16476  */
16477 void
16478 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
16479                                   gint         column)
16480 {
16481   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16482
16483   if (column == tree_view->priv->tooltip_column)
16484     return;
16485
16486   if (column == -1)
16487     {
16488       g_signal_handlers_disconnect_by_func (tree_view,
16489                                             gtk_tree_view_set_tooltip_query_cb,
16490                                             NULL);
16491       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
16492     }
16493   else
16494     {
16495       if (tree_view->priv->tooltip_column == -1)
16496         {
16497           g_signal_connect (tree_view, "query-tooltip",
16498                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
16499           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
16500         }
16501     }
16502
16503   tree_view->priv->tooltip_column = column;
16504   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
16505 }
16506
16507 /**
16508  * gtk_tree_view_get_tooltip_column:
16509  * @tree_view: a #GtkTreeView
16510  *
16511  * Returns the column of @tree_view's model which is being used for
16512  * displaying tooltips on @tree_view's rows.
16513  *
16514  * Return value: the index of the tooltip column that is currently being
16515  * used, or -1 if this is disabled.
16516  *
16517  * Since: 2.12
16518  */
16519 gint
16520 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
16521 {
16522   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16523
16524   return tree_view->priv->tooltip_column;
16525 }