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

   1 /* gtktreeview.c
   2  * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18
  19 #include "config.h"
  20
  21 #include <math.h>
  22 #include <string.h>
  23
  24 #include "gtktreeview.h"
  25
  26 #include "gtkadjustment.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 "gtksettings.h"
  54 #include "gtkwidgetpath.h"
  55 #include "a11y/gtktreeviewaccessible.h"
  56
  57
  58 /**
  59  * SECTION:gtktreeview
  60  * @Short_description: A widget for displaying both trees and lists
  61  * @Title: GtkTreeView
  62  * @See_also: #GtkTreeViewColumn, #GtkTreeSelection, #GtkTreeDnd, #GtkTreeMode,
  63  *   #GtkTreeSortable, #GtkTreeModelSort, #GtkListStore, #GtkTreeStore,
  64  *   #GtkCellRenderer, #GtkCellEditable, #GtkCellRendererPixbuf,
  65  *   #GtkCellRendererText, #GtkCellRendererToggle
  66  *
  67  * Widget that displays any object that implements the #GtkTreeModel interface.
  68  *
  69  * Please refer to the <link linkend="TreeWidget">tree widget conceptual
  70  * overview</link> for an overview of all the objects and data types related
  71  * to the tree widget and how they work together.
  72  *
  73  * Several different coordinate systems are exposed in the GtkTreeView API.
  74  * These are:
  75  *
  76  * <inlinegraphic fileref="tree-view-coordinates.png" format="PNG"></inlinegraphic>
  77  * <variablelist><title>Coordinate systems in GtkTreeView API</title>
  78  * <varlistentry><term>Widget coordinates</term>
  79  * <listitem>
  80  * <para>
  81  * Coordinates relative to the widget (usually <literal>widget->window</literal>).
  82  * </para>
  83  * </listitem>
  84  * </varlistentry>
  85  * <varlistentry><term>Bin window coordinates</term>
  86  * <listitem>
  87  * <para>
  88  * Coordinates relative to the window that GtkTreeView renders to.
  89  * </para>
  90  * </listitem>
  91  * </varlistentry>
  92  * <varlistentry><term>Tree coordinates</term>
  93  * <listitem>
  94  * <para>
  95  * Coordinates relative to the entire scrollable area of GtkTreeView. These
  96  * coordinates start at (0, 0) for row 0 of the tree.
  97  * </para>
  98  * </listitem>
  99  * </varlistentry>
 100  * </variablelist>
 101  *
 102  * Several functions are available for converting between the different
 103  * coordinate systems.  The most common translations are between widget and bin
 104  * window coordinates and between bin window and tree coordinates. For the
 105  * former you can use gtk_tree_view_convert_widget_to_bin_window_coords()
 106  * (and vice versa), for the latter gtk_tree_view_convert_bin_window_to_tree_coords()
 107  * (and vice versa).
 108  *
 109  * <refsect2 id="GtkTreeView-BUILDER-UI">
 110  * <title>GtkTreeView as GtkBuildable</title>
 111  * The GtkTreeView implementation of the GtkBuildable interface accepts
 112  * #GtkTreeViewColumn objects as &lt;child&gt; elements and exposes the
 113  * internal #GtkTreeSelection in UI definitions.
 114  * <example>
 115  * <title>A UI definition fragment with GtkTreeView</title>
 116  * <programlisting><![CDATA[
 117  * <object class="GtkTreeView" id="treeview">
 118  *   <property name="model">liststore1</property>
 119  *   <child>
 120  *     <object class="GtkTreeViewColumn" id="test-column">
 121  *       <property name="title">Test</property>
 122  *       <child>
 123  *         <object class="GtkCellRendererText" id="test-renderer"/>
 124  *         <attributes>
 125  *           <attribute name="text">1</attribute>
 126  *         </attributes>
 127  *       </child>
 128  *     </object>
 129  *   </child>
 130  *   <child internal-child="selection">
 131  *     <object class="GtkTreeSelection" id="selection">
 132  *       <signal name="changed" handler="on_treeview_selection_changed"/>
 133  *     </object>
 134  *   </child>
 135  * </object>
 136  * ]]></programlisting>
 137  * </example>
 138  * </refsect2>
 139  */
 140
 141 enum
 142 {
 143   DRAG_COLUMN_WINDOW_STATE_UNSET = 0,
 144   DRAG_COLUMN_WINDOW_STATE_ORIGINAL = 1,
 145   DRAG_COLUMN_WINDOW_STATE_ARROW = 2,
 146   DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT = 3,
 147   DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT = 4
 148 };
 149
 150 enum
 151 {
 152   RUBBER_BAND_OFF = 0,
 153   RUBBER_BAND_MAYBE_START = 1,
 154   RUBBER_BAND_ACTIVE = 2
 155 };
 156
 157 typedef enum {
 158   CLEAR_AND_SELECT = (1 << 0),
 159   CLAMP_NODE       = (1 << 1),
 160   CURSOR_INVALID   = (1 << 2)
 161 } SetCursorFlags;
 162
 163  /* This lovely little value is used to determine how far away from the title bar
 164   * you can move the mouse and still have a column drag work.
 165   */
 166 #define TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER(tree_view) (10*gtk_tree_view_get_effective_header_height(tree_view))
 167
 168 #ifdef __GNUC__
 169
 170 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 171      if (!(expr))                                                       \
 172        {                                                                \
 173          g_log (G_LOG_DOMAIN,                                           \
 174                 G_LOG_LEVEL_CRITICAL,                                   \
 175                 "%s (%s): assertion `%s' failed.\n"                     \
 176                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 177                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 178                 "without letting the view know.  Any display from now on is likely to\n"  \
 179                 "be incorrect.\n",                                                        \
 180                 G_STRLOC,                                               \
 181                 G_STRFUNC,                                              \
 182                 #expr);                                                 \
 183          return ret;                                                    \
 184        };                               }G_STMT_END
 185
 186 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 187      if (!(expr))                                                       \
 188        {                                                                \
 189          g_log (G_LOG_DOMAIN,                                           \
 190                 G_LOG_LEVEL_CRITICAL,                                   \
 191                 "%s (%s): assertion `%s' failed.\n"                     \
 192                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 193                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 194                 "without letting the view know.  Any display from now on is likely to\n"  \
 195                 "be incorrect.\n",                                                        \
 196                 G_STRLOC,                                               \
 197                 G_STRFUNC,                                              \
 198                 #expr);                                                 \
 199          return;                                                        \
 200        };                               }G_STMT_END
 201
 202 #else
 203
 204 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 205      if (!(expr))                                                       \
 206        {                                                                \
 207          g_log (G_LOG_DOMAIN,                                           \
 208                 G_LOG_LEVEL_CRITICAL,                                   \
 209                 "file %s: line %d: assertion `%s' failed.\n"       \
 210                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 211                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 212                 "without letting the view know.  Any display from now on is likely to\n"  \
 213                 "be incorrect.\n",                                                        \
 214                 __FILE__,                                               \
 215                 __LINE__,                                               \
 216                 #expr);                                                 \
 217          return ret;                                                    \
 218        };                               }G_STMT_END
 219
 220 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 221      if (!(expr))                                                       \
 222        {                                                                \
 223          g_log (G_LOG_DOMAIN,                                           \
 224                 G_LOG_LEVEL_CRITICAL,                                   \
 225                 "file %s: line %d: assertion '%s' failed.\n"            \
 226                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 227                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 228                 "without letting the view know.  Any display from now on is likely to\n"  \
 229                 "be incorrect.\n",                                                        \
 230                 __FILE__,                                               \
 231                 __LINE__,                                               \
 232                 #expr);                                                 \
 233          return;                                                        \
 234        };                               }G_STMT_END
 235 #endif
 236
 237 #define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
 238 #define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2)
 239 #define GTK_TREE_VIEW_TIME_MS_PER_IDLE 30
 240 #define SCROLL_EDGE_SIZE 15
 241 #define EXPANDER_EXTRA_PADDING 4
 242 #define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000
 243 #define AUTO_EXPAND_TIMEOUT 500
 244
 245 /* Translate from bin_window coordinates to rbtree (tree coordinates) and
 246  * vice versa.
 247  */
 248 #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy)
 249 #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy)
 250
 251 typedef struct _GtkTreeViewColumnReorder GtkTreeViewColumnReorder;
 252 struct _GtkTreeViewColumnReorder
 253 {
 254   gint left_align;
 255   gint right_align;
 256   GtkTreeViewColumn *left_column;
 257   GtkTreeViewColumn *right_column;
 258 };
 259
 260 typedef struct _GtkTreeViewChild GtkTreeViewChild;
 261 struct _GtkTreeViewChild
 262 {
 263   GtkWidget *widget;
 264   gint x;
 265   gint y;
 266   gint width;
 267   gint height;
 268 };
 269
 270
 271 typedef struct _TreeViewDragInfo TreeViewDragInfo;
 272 struct _TreeViewDragInfo
 273 {
 274   GdkModifierType start_button_mask;
 275   GtkTargetList *_unused_source_target_list;
 276   GdkDragAction source_actions;
 277
 278   GtkTargetList *_unused_dest_target_list;
 279
 280   guint source_set : 1;
 281   guint dest_set : 1;
 282 };
 283
 284
 285 struct _GtkTreeViewPrivate
 286 {
 287   GtkTreeModel *model;
 288
 289   /* tree information */
 290   GtkRBTree *tree;
 291
 292   /* Container info */
 293   GList *children;
 294   gint width;
 295   gint height;
 296
 297   /* Adjustments */
 298   GtkAdjustment *hadjustment;
 299   GtkAdjustment *vadjustment;
 300   gint           min_display_width;
 301   gint           min_display_height;
 302
 303   /* Sub windows */
 304   GdkWindow *bin_window;
 305   GdkWindow *header_window;
 306
 307   /* Scroll position state keeping */
 308   GtkTreeRowReference *top_row;
 309   gint top_row_dy;
 310   /* dy == y pos of top_row + top_row_dy */
 311   /* we cache it for simplicity of the code */
 312   gint dy;
 313
 314   guint presize_handler_timer;
 315   guint validate_rows_timer;
 316   guint scroll_sync_timer;
 317
 318   /* Indentation and expander layout */
 319   GtkTreeViewColumn *expander_column;
 320
 321   gint level_indentation;
 322
 323   /* Key navigation (focus), selection */
 324   gint cursor_offset;
 325
 326   GtkTreeRowReference *anchor;
 327   GtkRBNode *cursor_node;
 328   GtkRBTree *cursor_tree;
 329
 330   GtkTreeViewColumn *focus_column;
 331
 332   /* Current pressed node, previously pressed, prelight */
 333   GtkRBNode *button_pressed_node;
 334   GtkRBTree *button_pressed_tree;
 335
 336   gint pressed_button;
 337   gint press_start_x;
 338   gint press_start_y;
 339
 340   gint event_last_x;
 341   gint event_last_y;
 342
 343   guint last_button_time;
 344   gint last_button_x;
 345   gint last_button_y;
 346
 347   GtkRBNode *prelight_node;
 348   GtkRBTree *prelight_tree;
 349
 350   /* Cell Editing */
 351   GtkTreeViewColumn *edited_column;
 352
 353   /* The node that's currently being collapsed or expanded */
 354   GtkRBNode *expanded_collapsed_node;
 355   GtkRBTree *expanded_collapsed_tree;
 356   guint expand_collapse_timeout;
 357
 358   /* Auto expand/collapse timeout in hover mode */
 359   guint auto_expand_timeout;
 360
 361   /* Selection information */
 362   GtkTreeSelection *selection;
 363
 364   /* Header information */
 365   gint n_columns;
 366   GList *columns;
 367   gint header_height;
 368
 369   GtkTreeViewColumnDropFunc column_drop_func;
 370   gpointer column_drop_func_data;
 371   GDestroyNotify column_drop_func_data_destroy;
 372   GList *column_drag_info;
 373   GtkTreeViewColumnReorder *cur_reorder;
 374
 375   gint prev_width_before_expander;
 376
 377   /* Interactive Header reordering */
 378   GdkWindow *drag_window;
 379   GdkWindow *drag_highlight_window;
 380   GtkTreeViewColumn *drag_column;
 381   gint drag_column_x;
 382
 383   /* Interactive Header Resizing */
 384   gint drag_pos;
 385   gint x_drag;
 386
 387   /* Non-interactive Header Resizing, expand flag support */
 388   gint prev_width;
 389
 390   gint last_extra_space;
 391   gint last_extra_space_per_column;
 392   gint last_number_of_expand_columns;
 393
 394   /* ATK Hack */
 395   GtkTreeDestroyCountFunc destroy_count_func;
 396   gpointer destroy_count_data;
 397   GDestroyNotify destroy_count_destroy;
 398
 399   /* Scroll timeout (e.g. during dnd, rubber banding) */
 400   guint scroll_timeout;
 401
 402   /* Row drag-and-drop */
 403   GtkTreeRowReference *drag_dest_row;
 404   GtkTreeViewDropPosition drag_dest_pos;
 405   guint open_dest_timeout;
 406
 407   /* Rubber banding */
 408   gint rubber_band_status;
 409   gint rubber_band_x;
 410   gint rubber_band_y;
 411   gint rubber_band_extend;
 412   gint rubber_band_modify;
 413
 414   GtkRBNode *rubber_band_start_node;
 415   GtkRBTree *rubber_band_start_tree;
 416
 417   GtkRBNode *rubber_band_end_node;
 418   GtkRBTree *rubber_band_end_tree;
 419
 420   /* fixed height */
 421   gint fixed_height;
 422
 423   /* Scroll-to functionality when unrealized */
 424   GtkTreeRowReference *scroll_to_path;
 425   GtkTreeViewColumn *scroll_to_column;
 426   gfloat scroll_to_row_align;
 427   gfloat scroll_to_col_align;
 428
 429   /* Interactive search */
 430   gint selected_iter;
 431   gint search_column;
 432   GtkTreeViewSearchPositionFunc search_position_func;
 433   GtkTreeViewSearchEqualFunc search_equal_func;
 434   gpointer search_user_data;
 435   GDestroyNotify search_destroy;
 436   gpointer search_position_user_data;
 437   GDestroyNotify search_position_destroy;
 438   GtkWidget *search_window;
 439   GtkWidget *search_entry;
 440   gulong search_entry_changed_id;
 441   guint typeselect_flush_timeout;
 442
 443   /* Grid and tree lines */
 444   GtkTreeViewGridLines grid_lines;
 445   double grid_line_dashes[2];
 446   int grid_line_width;
 447
 448   gboolean tree_lines_enabled;
 449   double tree_line_dashes[2];
 450   int tree_line_width;
 451
 452   /* Row separators */
 453   GtkTreeViewRowSeparatorFunc row_separator_func;
 454   gpointer row_separator_data;
 455   GDestroyNotify row_separator_destroy;
 456
 457   /* Tooltip support */
 458   gint tooltip_column;
 459
 460   /* Here comes the bitfield */
 461   guint scroll_to_use_align : 1;
 462
 463   guint fixed_height_mode : 1;
 464   guint fixed_height_check : 1;
 465
 466   guint reorderable : 1;
 467   guint header_has_focus : 1;
 468   guint drag_column_window_state : 3;
 469   /* hint to display rows in alternating colors */
 470   guint has_rules : 1;
 471   guint mark_rows_col_dirty : 1;
 472
 473   /* for DnD */
 474   guint empty_view_drop : 1;
 475
 476   guint modify_selection_pressed : 1;
 477   guint extend_selection_pressed : 1;
 478
 479   guint init_hadjust_value : 1;
 480
 481   guint in_top_row_to_dy : 1;
 482
 483   /* interactive search */
 484   guint enable_search : 1;
 485   guint disable_popdown : 1;
 486   guint search_custom_entry_set : 1;
 487
 488   guint hover_selection : 1;
 489   guint hover_expand : 1;
 490   guint imcontext_changed : 1;
 491
 492   guint rubber_banding_enable : 1;
 493
 494   guint in_grab : 1;
 495
 496   guint post_validation_flag : 1;
 497
 498   /* Whether our key press handler is to avoid sending an unhandled binding to the search entry */
 499   guint search_entry_avoid_unhandled_binding : 1;
 500
 501   /* GtkScrollablePolicy needs to be checked when
 502    * driving the scrollable adjustment values */
 503   guint hscroll_policy : 1;
 504   guint vscroll_policy : 1;
 505
 506   /* GtkTreeView flags */
 507   guint is_list : 1;
 508   guint show_expanders : 1;
 509   guint in_column_resize : 1;
 510   guint arrow_prelit : 1;
 511   guint headers_visible : 1;
 512   guint draw_keyfocus : 1;
 513   guint model_setup : 1;
 514   guint in_column_drag : 1;
 515 };
 516
 517
 518 /* Signals */
 519 enum
 520 {
 521   ROW_ACTIVATED,
 522   TEST_EXPAND_ROW,
 523   TEST_COLLAPSE_ROW,
 524   ROW_EXPANDED,
 525   ROW_COLLAPSED,
 526   COLUMNS_CHANGED,
 527   CURSOR_CHANGED,
 528   MOVE_CURSOR,
 529   SELECT_ALL,
 530   UNSELECT_ALL,
 531   SELECT_CURSOR_ROW,
 532   TOGGLE_CURSOR_ROW,
 533   EXPAND_COLLAPSE_CURSOR_ROW,
 534   SELECT_CURSOR_PARENT,
 535   START_INTERACTIVE_SEARCH,
 536   LAST_SIGNAL
 537 };
 538
 539 /* Properties */
 540 enum {
 541   PROP_0,
 542   PROP_MODEL,
 543   PROP_HADJUSTMENT,
 544   PROP_VADJUSTMENT,
 545   PROP_HSCROLL_POLICY,
 546   PROP_VSCROLL_POLICY,
 547   PROP_HEADERS_VISIBLE,
 548   PROP_HEADERS_CLICKABLE,
 549   PROP_EXPANDER_COLUMN,
 550   PROP_REORDERABLE,
 551   PROP_RULES_HINT,
 552   PROP_ENABLE_SEARCH,
 553   PROP_SEARCH_COLUMN,
 554   PROP_FIXED_HEIGHT_MODE,
 555   PROP_HOVER_SELECTION,
 556   PROP_HOVER_EXPAND,
 557   PROP_SHOW_EXPANDERS,
 558   PROP_LEVEL_INDENTATION,
 559   PROP_RUBBER_BANDING,
 560   PROP_ENABLE_GRID_LINES,
 561   PROP_ENABLE_TREE_LINES,
 562   PROP_TOOLTIP_COLUMN
 563 };
 564
 565 /* object signals */
 566 static void     gtk_tree_view_finalize             (GObject          *object);
 567 static void     gtk_tree_view_set_property         (GObject         *object,
 568                                                     guint            prop_id,
 569                                                     const GValue    *value,
 570                                                     GParamSpec      *pspec);
 571 static void     gtk_tree_view_get_property         (GObject         *object,
 572                                                     guint            prop_id,
 573                                                     GValue          *value,
 574                                                     GParamSpec      *pspec);
 575
 576 /* gtkwidget signals */
 577 static void     gtk_tree_view_destroy              (GtkWidget        *widget);
 578 static void     gtk_tree_view_realize              (GtkWidget        *widget);
 579 static void     gtk_tree_view_unrealize            (GtkWidget        *widget);
 580 static void     gtk_tree_view_map                  (GtkWidget        *widget);
 581 static void     gtk_tree_view_get_preferred_width  (GtkWidget        *widget,
 582                                                     gint             *minimum,
 583                                                     gint             *natural);
 584 static void     gtk_tree_view_get_preferred_height (GtkWidget        *widget,
 585                                                     gint             *minimum,
 586                                                     gint             *natural);
 587 static void     gtk_tree_view_size_request         (GtkWidget        *widget,
 588                                                     GtkRequisition   *requisition,
 589                                                     gboolean          may_validate);
 590 static void     gtk_tree_view_size_allocate        (GtkWidget        *widget,
 591                                                     GtkAllocation    *allocation);
 592 static gboolean gtk_tree_view_draw                 (GtkWidget        *widget,
 593                                                     cairo_t          *cr);
 594 static gboolean gtk_tree_view_key_press            (GtkWidget        *widget,
 595                                                     GdkEventKey      *event);
 596 static gboolean gtk_tree_view_key_release          (GtkWidget        *widget,
 597                                                     GdkEventKey      *event);
 598 static gboolean gtk_tree_view_motion               (GtkWidget        *widget,
 599                                                     GdkEventMotion   *event);
 600 static gboolean gtk_tree_view_enter_notify         (GtkWidget        *widget,
 601                                                     GdkEventCrossing *event);
 602 static gboolean gtk_tree_view_leave_notify         (GtkWidget        *widget,
 603                                                     GdkEventCrossing *event);
 604 static gboolean gtk_tree_view_button_press         (GtkWidget        *widget,
 605                                                     GdkEventButton   *event);
 606 static gboolean gtk_tree_view_button_release       (GtkWidget        *widget,
 607                                                     GdkEventButton   *event);
 608 static gboolean gtk_tree_view_grab_broken          (GtkWidget          *widget,
 609                                                     GdkEventGrabBroken *event);
 610 #if 0
 611 static gboolean gtk_tree_view_configure            (GtkWidget         *widget,
 612                                                     GdkEventConfigure *event);
 613 #endif
 614
 615 static GtkWidgetPath * gtk_tree_view_get_path_for_child (GtkContainer *container,
 616                                                          GtkWidget    *child);
 617
 618 static void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 619                                                     GtkWidget        *child);
 620 static gint     gtk_tree_view_focus_out            (GtkWidget        *widget,
 621                                                     GdkEventFocus    *event);
 622 static gint     gtk_tree_view_focus                (GtkWidget        *widget,
 623                                                     GtkDirectionType  direction);
 624 static void     gtk_tree_view_grab_focus           (GtkWidget        *widget);
 625 static void     gtk_tree_view_style_updated        (GtkWidget        *widget);
 626 static void     gtk_tree_view_grab_notify          (GtkWidget        *widget,
 627                                                     gboolean          was_grabbed);
 628 static void     gtk_tree_view_state_flags_changed  (GtkWidget        *widget,
 629                                                     GtkStateFlags     previous_state);
 630
 631 /* container signals */
 632 static void     gtk_tree_view_remove               (GtkContainer     *container,
 633                                                     GtkWidget        *widget);
 634 static void     gtk_tree_view_forall               (GtkContainer     *container,
 635                                                     gboolean          include_internals,
 636                                                     GtkCallback       callback,
 637                                                     gpointer          callback_data);
 638
 639 /* Source side drag signals */
 640 static void gtk_tree_view_drag_begin       (GtkWidget        *widget,
 641                                             GdkDragContext   *context);
 642 static void gtk_tree_view_drag_end         (GtkWidget        *widget,
 643                                             GdkDragContext   *context);
 644 static void gtk_tree_view_drag_data_get    (GtkWidget        *widget,
 645                                             GdkDragContext   *context,
 646                                             GtkSelectionData *selection_data,
 647                                             guint             info,
 648                                             guint             time);
 649 static void gtk_tree_view_drag_data_delete (GtkWidget        *widget,
 650                                             GdkDragContext   *context);
 651
 652 /* Target side drag signals */
 653 static void     gtk_tree_view_drag_leave         (GtkWidget        *widget,
 654                                                   GdkDragContext   *context,
 655                                                   guint             time);
 656 static gboolean gtk_tree_view_drag_motion        (GtkWidget        *widget,
 657                                                   GdkDragContext   *context,
 658                                                   gint              x,
 659                                                   gint              y,
 660                                                   guint             time);
 661 static gboolean gtk_tree_view_drag_drop          (GtkWidget        *widget,
 662                                                   GdkDragContext   *context,
 663                                                   gint              x,
 664                                                   gint              y,
 665                                                   guint             time);
 666 static void     gtk_tree_view_drag_data_received (GtkWidget        *widget,
 667                                                   GdkDragContext   *context,
 668                                                   gint              x,
 669                                                   gint              y,
 670                                                   GtkSelectionData *selection_data,
 671                                                   guint             info,
 672                                                   guint             time);
 673
 674 /* tree_model signals */
 675 static gboolean gtk_tree_view_real_move_cursor            (GtkTreeView     *tree_view,
 676                                                            GtkMovementStep  step,
 677                                                            gint             count);
 678 static gboolean gtk_tree_view_real_select_all             (GtkTreeView     *tree_view);
 679 static gboolean gtk_tree_view_real_unselect_all           (GtkTreeView     *tree_view);
 680 static gboolean gtk_tree_view_real_select_cursor_row      (GtkTreeView     *tree_view,
 681                                                            gboolean         start_editing);
 682 static gboolean gtk_tree_view_real_toggle_cursor_row      (GtkTreeView     *tree_view);
 683 static gboolean gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView     *tree_view,
 684                                                                gboolean         logical,
 685                                                                gboolean         expand,
 686                                                                gboolean         open_all);
 687 static gboolean gtk_tree_view_real_select_cursor_parent   (GtkTreeView     *tree_view);
 688 static void gtk_tree_view_row_changed                     (GtkTreeModel    *model,
 689                                                            GtkTreePath     *path,
 690                                                            GtkTreeIter     *iter,
 691                                                            gpointer         data);
 692 static void gtk_tree_view_row_inserted                    (GtkTreeModel    *model,
 693                                                            GtkTreePath     *path,
 694                                                            GtkTreeIter     *iter,
 695                                                            gpointer         data);
 696 static void gtk_tree_view_row_has_child_toggled           (GtkTreeModel    *model,
 697                                                            GtkTreePath     *path,
 698                                                            GtkTreeIter     *iter,
 699                                                            gpointer         data);
 700 static void gtk_tree_view_row_deleted                     (GtkTreeModel    *model,
 701                                                            GtkTreePath     *path,
 702                                                            gpointer         data);
 703 static void gtk_tree_view_rows_reordered                  (GtkTreeModel    *model,
 704                                                            GtkTreePath     *parent,
 705                                                            GtkTreeIter     *iter,
 706                                                            gint            *new_order,
 707                                                            gpointer         data);
 708
 709 /* Incremental reflow */
 710 static gboolean validate_row             (GtkTreeView *tree_view,
 711                                           GtkRBTree   *tree,
 712                                           GtkRBNode   *node,
 713                                           GtkTreeIter *iter,
 714                                           GtkTreePath *path);
 715 static void     validate_visible_area    (GtkTreeView *tree_view);
 716 static gboolean validate_rows_handler    (GtkTreeView *tree_view);
 717 static gboolean do_validate_rows         (GtkTreeView *tree_view,
 718                                           gboolean     size_request);
 719 static gboolean validate_rows            (GtkTreeView *tree_view);
 720 static gboolean presize_handler_callback (gpointer     data);
 721 static void     install_presize_handler  (GtkTreeView *tree_view);
 722 static void     install_scroll_sync_handler (GtkTreeView *tree_view);
 723 static void     gtk_tree_view_set_top_row   (GtkTreeView *tree_view,
 724                                              GtkTreePath *path,
 725                                              gint         offset);
 726 static void     gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view);
 727 static void     gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view);
 728 static void     invalidate_empty_focus      (GtkTreeView *tree_view);
 729
 730 /* Internal functions */
 731 static gboolean gtk_tree_view_is_expander_column             (GtkTreeView        *tree_view,
 732                                                               GtkTreeViewColumn  *column);
 733 static inline gboolean gtk_tree_view_draw_expanders          (GtkTreeView        *tree_view);
 734 static void     gtk_tree_view_add_move_binding               (GtkBindingSet      *binding_set,
 735                                                               guint               keyval,
 736                                                               guint               modmask,
 737                                                               gboolean            add_shifted_binding,
 738                                                               GtkMovementStep     step,
 739                                                               gint                count);
 740 static gint     gtk_tree_view_unref_and_check_selection_tree (GtkTreeView        *tree_view,
 741                                                               GtkRBTree          *tree);
 742 static void     gtk_tree_view_queue_draw_path                (GtkTreeView        *tree_view,
 743                                                               GtkTreePath        *path,
 744                                                               const GdkRectangle *clip_rect);
 745 static void     gtk_tree_view_queue_draw_arrow               (GtkTreeView        *tree_view,
 746                                                               GtkRBTree          *tree,
 747                                                               GtkRBNode          *node);
 748 static void     gtk_tree_view_draw_arrow                     (GtkTreeView        *tree_view,
 749                                                               cairo_t            *cr,
 750                                                               GtkRBTree          *tree,
 751                                                               GtkRBNode          *node);
 752 static void     gtk_tree_view_get_arrow_xrange               (GtkTreeView        *tree_view,
 753                                                               GtkRBTree          *tree,
 754                                                               gint               *x1,
 755                                                               gint               *x2);
 756 static gint     gtk_tree_view_new_column_width               (GtkTreeView        *tree_view,
 757                                                               gint                i,
 758                                                               gint               *x);
 759 static void     gtk_tree_view_adjustment_changed             (GtkAdjustment      *adjustment,
 760                                                               GtkTreeView        *tree_view);
 761 static void     gtk_tree_view_build_tree                     (GtkTreeView        *tree_view,
 762                                                               GtkRBTree          *tree,
 763                                                               GtkTreeIter        *iter,
 764                                                               gint                depth,
 765                                                               gboolean            recurse);
 766 static void     gtk_tree_view_clamp_node_visible             (GtkTreeView        *tree_view,
 767                                                               GtkRBTree          *tree,
 768                                                               GtkRBNode          *node);
 769 static void     gtk_tree_view_clamp_column_visible           (GtkTreeView        *tree_view,
 770                                                               GtkTreeViewColumn  *column,
 771                                                               gboolean            focus_to_cell);
 772 static gboolean gtk_tree_view_maybe_begin_dragging_row       (GtkTreeView        *tree_view,
 773                                                               GdkEventMotion     *event);
 774 static void     gtk_tree_view_focus_to_cursor                (GtkTreeView        *tree_view);
 775 static void     gtk_tree_view_move_cursor_up_down            (GtkTreeView        *tree_view,
 776                                                               gint                count);
 777 static void     gtk_tree_view_move_cursor_page_up_down       (GtkTreeView        *tree_view,
 778                                                               gint                count);
 779 static void     gtk_tree_view_move_cursor_left_right         (GtkTreeView        *tree_view,
 780                                                               gint                count);
 781 static void     gtk_tree_view_move_cursor_start_end          (GtkTreeView        *tree_view,
 782                                                               gint                count);
 783 static gboolean gtk_tree_view_real_collapse_row              (GtkTreeView        *tree_view,
 784                                                               GtkTreePath        *path,
 785                                                               GtkRBTree          *tree,
 786                                                               GtkRBNode          *node,
 787                                                               gboolean            animate);
 788 static gboolean gtk_tree_view_real_expand_row                (GtkTreeView        *tree_view,
 789                                                               GtkTreePath        *path,
 790                                                               GtkRBTree          *tree,
 791                                                               GtkRBNode          *node,
 792                                                               gboolean            open_all,
 793                                                               gboolean            animate);
 794 static void     gtk_tree_view_real_set_cursor                (GtkTreeView        *tree_view,
 795                                                               GtkTreePath        *path,
 796                                                               SetCursorFlags      flags);
 797 static gboolean gtk_tree_view_has_can_focus_cell             (GtkTreeView        *tree_view);
 798 static void     column_sizing_notify                         (GObject            *object,
 799                                                               GParamSpec         *pspec,
 800                                                               gpointer            data);
 801 static void     gtk_tree_view_stop_rubber_band               (GtkTreeView        *tree_view);
 802 static void     update_prelight                              (GtkTreeView        *tree_view,
 803                                                               int                 x,
 804                                                               int                 y);
 805
 806 static inline gint gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view);
 807
 808 static inline gint gtk_tree_view_get_cell_area_y_offset      (GtkTreeView *tree_view,
 809                                                               GtkRBTree   *tree,
 810                                                               GtkRBNode   *node,
 811                                                               gint         vertical_separator);
 812 static inline gint gtk_tree_view_get_cell_area_height        (GtkTreeView *tree_view,
 813                                                               GtkRBNode   *node,
 814                                                               gint         vertical_separator);
 815
 816 static inline gint gtk_tree_view_get_row_y_offset            (GtkTreeView *tree_view,
 817                                                               GtkRBTree   *tree,
 818                                                               GtkRBNode   *node);
 819 static inline gint gtk_tree_view_get_row_height              (GtkTreeView *tree_view,
 820                                                               GtkRBNode   *node);
 821
 822 /* interactive search */
 823 static void     gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view);
 824 static void     gtk_tree_view_search_dialog_hide        (GtkWidget        *search_dialog,
 825                                                          GtkTreeView      *tree_view,
 826                                                          GdkDevice        *device);
 827 static void     gtk_tree_view_search_position_func      (GtkTreeView      *tree_view,
 828                                                          GtkWidget        *search_dialog,
 829                                                          gpointer          user_data);
 830 static void     gtk_tree_view_search_disable_popdown    (GtkEntry         *entry,
 831                                                          GtkMenu          *menu,
 832                                                          gpointer          data);
 833 static void     gtk_tree_view_search_preedit_changed    (GtkIMContext     *im_context,
 834                                                          GtkTreeView      *tree_view);
 835 static void     gtk_tree_view_search_activate           (GtkEntry         *entry,
 836                                                          GtkTreeView      *tree_view);
 837 static gboolean gtk_tree_view_real_search_enable_popdown(gpointer          data);
 838 static void     gtk_tree_view_search_enable_popdown     (GtkWidget        *widget,
 839                                                          gpointer          data);
 840 static gboolean gtk_tree_view_search_delete_event       (GtkWidget        *widget,
 841                                                          GdkEventAny      *event,
 842                                                          GtkTreeView      *tree_view);
 843 static gboolean gtk_tree_view_search_button_press_event (GtkWidget        *widget,
 844                                                          GdkEventButton   *event,
 845                                                          GtkTreeView      *tree_view);
 846 static gboolean gtk_tree_view_search_scroll_event       (GtkWidget        *entry,
 847                                                          GdkEventScroll   *event,
 848                                                          GtkTreeView      *tree_view);
 849 static gboolean gtk_tree_view_search_key_press_event    (GtkWidget        *entry,
 850                                                          GdkEventKey      *event,
 851                                                          GtkTreeView      *tree_view);
 852 static gboolean gtk_tree_view_search_move               (GtkWidget        *window,
 853                                                          GtkTreeView      *tree_view,
 854                                                          gboolean          up);
 855 static gboolean gtk_tree_view_search_equal_func         (GtkTreeModel     *model,
 856                                                          gint              column,
 857                                                          const gchar      *key,
 858                                                          GtkTreeIter      *iter,
 859                                                          gpointer          search_data);
 860 static gboolean gtk_tree_view_search_iter               (GtkTreeModel     *model,
 861                                                          GtkTreeSelection *selection,
 862                                                          GtkTreeIter      *iter,
 863                                                          const gchar      *text,
 864                                                          gint             *count,
 865                                                          gint              n);
 866 static void     gtk_tree_view_search_init               (GtkWidget        *entry,
 867                                                          GtkTreeView      *tree_view);
 868 static void     gtk_tree_view_put                       (GtkTreeView      *tree_view,
 869                                                          GtkWidget        *child_widget,
 870                                                          gint              x,
 871                                                          gint              y,
 872                                                          gint              width,
 873                                                          gint              height);
 874 static gboolean gtk_tree_view_start_editing             (GtkTreeView      *tree_view,
 875                                                          GtkTreePath      *cursor_path,
 876                                                          gboolean          edit_only);
 877 static void gtk_tree_view_stop_editing                  (GtkTreeView *tree_view,
 878                                                          gboolean     cancel_editing);
 879 static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
 880                                                              GdkDevice   *device,
 881                                                              gboolean     keybinding);
 882 static gboolean gtk_tree_view_start_interactive_search      (GtkTreeView *tree_view);
 883 static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
 884                                                          GtkTreeViewColumn *column,
 885                                                          gint               drop_position);
 886
 887 /* GtkBuildable */
 888 static void     gtk_tree_view_buildable_add_child          (GtkBuildable      *tree_view,
 889                                                             GtkBuilder        *builder,
 890                                                             GObject           *child,
 891                                                             const gchar       *type);
 892 static GObject *gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
 893                                                             GtkBuilder        *builder,
 894                                                             const gchar       *childname);
 895 static void     gtk_tree_view_buildable_init               (GtkBuildableIface *iface);
 896
 897 static GtkAdjustment *gtk_tree_view_do_get_hadjustment (GtkTreeView   *tree_view);
 898 static void           gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
 899                                                         GtkAdjustment *adjustment);
 900 static GtkAdjustment *gtk_tree_view_do_get_vadjustment (GtkTreeView   *tree_view);
 901 static void           gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
 902                                                         GtkAdjustment *adjustment);
 903
 904 static gboolean scroll_row_timeout                   (gpointer     data);
 905 static void     add_scroll_timeout                   (GtkTreeView *tree_view);
 906 static void     remove_scroll_timeout                (GtkTreeView *tree_view);
 907
 908 static guint tree_view_signals [LAST_SIGNAL] = { 0 };
 909
 910 \f
 911
 912 /* GType Methods
 913  */
 914
 915 G_DEFINE_TYPE_WITH_CODE (GtkTreeView, gtk_tree_view, GTK_TYPE_CONTAINER,
 916                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 917                                                 gtk_tree_view_buildable_init)
 918                          G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
 919
 920 static void
 921 gtk_tree_view_class_init (GtkTreeViewClass *class)
 922 {
 923   GObjectClass *o_class;
 924   GtkWidgetClass *widget_class;
 925   GtkContainerClass *container_class;
 926   GtkBindingSet *binding_set;
 927
 928   binding_set = gtk_binding_set_by_class (class);
 929
 930   o_class = (GObjectClass *) class;
 931   widget_class = (GtkWidgetClass *) class;
 932   container_class = (GtkContainerClass *) class;
 933
 934   /* GObject signals */
 935   o_class->set_property = gtk_tree_view_set_property;
 936   o_class->get_property = gtk_tree_view_get_property;
 937   o_class->finalize = gtk_tree_view_finalize;
 938
 939   /* GtkWidget signals */
 940   widget_class->destroy = gtk_tree_view_destroy;
 941   widget_class->map = gtk_tree_view_map;
 942   widget_class->realize = gtk_tree_view_realize;
 943   widget_class->unrealize = gtk_tree_view_unrealize;
 944   widget_class->get_preferred_width = gtk_tree_view_get_preferred_width;
 945   widget_class->get_preferred_height = gtk_tree_view_get_preferred_height;
 946   widget_class->size_allocate = gtk_tree_view_size_allocate;
 947   widget_class->button_press_event = gtk_tree_view_button_press;
 948   widget_class->button_release_event = gtk_tree_view_button_release;
 949   widget_class->grab_broken_event = gtk_tree_view_grab_broken;
 950   /*widget_class->configure_event = gtk_tree_view_configure;*/
 951   widget_class->motion_notify_event = gtk_tree_view_motion;
 952   widget_class->draw = gtk_tree_view_draw;
 953   widget_class->key_press_event = gtk_tree_view_key_press;
 954   widget_class->key_release_event = gtk_tree_view_key_release;
 955   widget_class->enter_notify_event = gtk_tree_view_enter_notify;
 956   widget_class->leave_notify_event = gtk_tree_view_leave_notify;
 957   widget_class->focus_out_event = gtk_tree_view_focus_out;
 958   widget_class->drag_begin = gtk_tree_view_drag_begin;
 959   widget_class->drag_end = gtk_tree_view_drag_end;
 960   widget_class->drag_data_get = gtk_tree_view_drag_data_get;
 961   widget_class->drag_data_delete = gtk_tree_view_drag_data_delete;
 962   widget_class->drag_leave = gtk_tree_view_drag_leave;
 963   widget_class->drag_motion = gtk_tree_view_drag_motion;
 964   widget_class->drag_drop = gtk_tree_view_drag_drop;
 965   widget_class->drag_data_received = gtk_tree_view_drag_data_received;
 966   widget_class->focus = gtk_tree_view_focus;
 967   widget_class->grab_focus = gtk_tree_view_grab_focus;
 968   widget_class->style_updated = gtk_tree_view_style_updated;
 969   widget_class->grab_notify = gtk_tree_view_grab_notify;
 970   widget_class->state_flags_changed = gtk_tree_view_state_flags_changed;
 971
 972   /* GtkContainer signals */
 973   container_class->remove = gtk_tree_view_remove;
 974   container_class->forall = gtk_tree_view_forall;
 975   container_class->set_focus_child = gtk_tree_view_set_focus_child;
 976   container_class->get_path_for_child = gtk_tree_view_get_path_for_child;
 977
 978   class->move_cursor = gtk_tree_view_real_move_cursor;
 979   class->select_all = gtk_tree_view_real_select_all;
 980   class->unselect_all = gtk_tree_view_real_unselect_all;
 981   class->select_cursor_row = gtk_tree_view_real_select_cursor_row;
 982   class->toggle_cursor_row = gtk_tree_view_real_toggle_cursor_row;
 983   class->expand_collapse_cursor_row = gtk_tree_view_real_expand_collapse_cursor_row;
 984   class->select_cursor_parent = gtk_tree_view_real_select_cursor_parent;
 985   class->start_interactive_search = gtk_tree_view_start_interactive_search;
 986
 987   /* Properties */
 988
 989   g_object_class_install_property (o_class,
 990                                    PROP_MODEL,
 991                                    g_param_spec_object ("model",
 992                                                         P_("TreeView Model"),
 993                                                         P_("The model for the tree view"),
 994                                                         GTK_TYPE_TREE_MODEL,
 995                                                         GTK_PARAM_READWRITE));
 996
 997   g_object_class_override_property (o_class, PROP_HADJUSTMENT,    "hadjustment");
 998   g_object_class_override_property (o_class, PROP_VADJUSTMENT,    "vadjustment");
 999   g_object_class_override_property (o_class, PROP_HSCROLL_POLICY, "hscroll-policy");
1000   g_object_class_override_property (o_class, PROP_VSCROLL_POLICY, "vscroll-policy");
1001
1002   g_object_class_install_property (o_class,
1003                                    PROP_HEADERS_VISIBLE,
1004                                    g_param_spec_boolean ("headers-visible",
1005                                                          P_("Headers Visible"),
1006                                                          P_("Show the column header buttons"),
1007                                                          TRUE,
1008                                                          GTK_PARAM_READWRITE));
1009
1010   g_object_class_install_property (o_class,
1011                                    PROP_HEADERS_CLICKABLE,
1012                                    g_param_spec_boolean ("headers-clickable",
1013                                                          P_("Headers Clickable"),
1014                                                          P_("Column headers respond to click events"),
1015                                                          TRUE,
1016                                                          GTK_PARAM_READWRITE));
1017
1018   g_object_class_install_property (o_class,
1019                                    PROP_EXPANDER_COLUMN,
1020                                    g_param_spec_object ("expander-column",
1021                                                         P_("Expander Column"),
1022                                                         P_("Set the column for the expander column"),
1023                                                         GTK_TYPE_TREE_VIEW_COLUMN,
1024                                                         GTK_PARAM_READWRITE));
1025
1026   g_object_class_install_property (o_class,
1027                                    PROP_REORDERABLE,
1028                                    g_param_spec_boolean ("reorderable",
1029                                                          P_("Reorderable"),
1030                                                          P_("View is reorderable"),
1031                                                          FALSE,
1032                                                          GTK_PARAM_READWRITE));
1033
1034   g_object_class_install_property (o_class,
1035                                    PROP_RULES_HINT,
1036                                    g_param_spec_boolean ("rules-hint",
1037                                                          P_("Rules Hint"),
1038                                                          P_("Set a hint to the theme engine to draw rows in alternating colors"),
1039                                                          FALSE,
1040                                                          GTK_PARAM_READWRITE));
1041
1042     g_object_class_install_property (o_class,
1043                                      PROP_ENABLE_SEARCH,
1044                                      g_param_spec_boolean ("enable-search",
1045                                                            P_("Enable Search"),
1046                                                            P_("View allows user to search through columns interactively"),
1047                                                            TRUE,
1048                                                            GTK_PARAM_READWRITE));
1049
1050     g_object_class_install_property (o_class,
1051                                      PROP_SEARCH_COLUMN,
1052                                      g_param_spec_int ("search-column",
1053                                                        P_("Search Column"),
1054                                                        P_("Model column to search through during interactive search"),
1055                                                        -1,
1056                                                        G_MAXINT,
1057                                                        -1,
1058                                                        GTK_PARAM_READWRITE));
1059
1060     /**
1061      * GtkTreeView:fixed-height-mode:
1062      *
1063      * Setting the ::fixed-height-mode property to %TRUE speeds up
1064      * #GtkTreeView by assuming that all rows have the same height.
1065      * Only enable this option if all rows are the same height.
1066      * Please see gtk_tree_view_set_fixed_height_mode() for more
1067      * information on this option.
1068      *
1069      * Since: 2.4
1070      **/
1071     g_object_class_install_property (o_class,
1072                                      PROP_FIXED_HEIGHT_MODE,
1073                                      g_param_spec_boolean ("fixed-height-mode",
1074                                                            P_("Fixed Height Mode"),
1075                                                            P_("Speeds up GtkTreeView by assuming that all rows have the same height"),
1076                                                            FALSE,
1077                                                            GTK_PARAM_READWRITE));
1078
1079     /**
1080      * GtkTreeView:hover-selection:
1081      *
1082      * Enables or disables the hover selection mode of @tree_view.
1083      * Hover selection makes the selected row follow the pointer.
1084      * Currently, this works only for the selection modes
1085      * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
1086      *
1087      * This mode is primarily intended for treeviews in popups, e.g.
1088      * in #GtkComboBox or #GtkEntryCompletion.
1089      *
1090      * Since: 2.6
1091      */
1092     g_object_class_install_property (o_class,
1093                                      PROP_HOVER_SELECTION,
1094                                      g_param_spec_boolean ("hover-selection",
1095                                                            P_("Hover Selection"),
1096                                                            P_("Whether the selection should follow the pointer"),
1097                                                            FALSE,
1098                                                            GTK_PARAM_READWRITE));
1099
1100     /**
1101      * GtkTreeView:hover-expand:
1102      *
1103      * Enables or disables the hover expansion mode of @tree_view.
1104      * Hover expansion makes rows expand or collapse if the pointer moves
1105      * over them.
1106      *
1107      * This mode is primarily intended for treeviews in popups, e.g.
1108      * in #GtkComboBox or #GtkEntryCompletion.
1109      *
1110      * Since: 2.6
1111      */
1112     g_object_class_install_property (o_class,
1113                                      PROP_HOVER_EXPAND,
1114                                      g_param_spec_boolean ("hover-expand",
1115                                                            P_("Hover Expand"),
1116                                                            P_("Whether rows should be expanded/collapsed when the pointer moves over them"),
1117                                                            FALSE,
1118                                                            GTK_PARAM_READWRITE));
1119
1120     /**
1121      * GtkTreeView:show-expanders:
1122      *
1123      * %TRUE if the view has expanders.
1124      *
1125      * Since: 2.12
1126      */
1127     g_object_class_install_property (o_class,
1128                                      PROP_SHOW_EXPANDERS,
1129                                      g_param_spec_boolean ("show-expanders",
1130                                                            P_("Show Expanders"),
1131                                                            P_("View has expanders"),
1132                                                            TRUE,
1133                                                            GTK_PARAM_READWRITE));
1134
1135     /**
1136      * GtkTreeView:level-indentation:
1137      *
1138      * Extra indentation for each level.
1139      *
1140      * Since: 2.12
1141      */
1142     g_object_class_install_property (o_class,
1143                                      PROP_LEVEL_INDENTATION,
1144                                      g_param_spec_int ("level-indentation",
1145                                                        P_("Level Indentation"),
1146                                                        P_("Extra indentation for each level"),
1147                                                        0,
1148                                                        G_MAXINT,
1149                                                        0,
1150                                                        GTK_PARAM_READWRITE));
1151
1152     g_object_class_install_property (o_class,
1153                                      PROP_RUBBER_BANDING,
1154                                      g_param_spec_boolean ("rubber-banding",
1155                                                            P_("Rubber Banding"),
1156                                                            P_("Whether to enable selection of multiple items by dragging the mouse pointer"),
1157                                                            FALSE,
1158                                                            GTK_PARAM_READWRITE));
1159
1160     g_object_class_install_property (o_class,
1161                                      PROP_ENABLE_GRID_LINES,
1162                                      g_param_spec_enum ("enable-grid-lines",
1163                                                         P_("Enable Grid Lines"),
1164                                                         P_("Whether grid lines should be drawn in the tree view"),
1165                                                         GTK_TYPE_TREE_VIEW_GRID_LINES,
1166                                                         GTK_TREE_VIEW_GRID_LINES_NONE,
1167                                                         GTK_PARAM_READWRITE));
1168
1169     g_object_class_install_property (o_class,
1170                                      PROP_ENABLE_TREE_LINES,
1171                                      g_param_spec_boolean ("enable-tree-lines",
1172                                                            P_("Enable Tree Lines"),
1173                                                            P_("Whether tree lines should be drawn in the tree view"),
1174                                                            FALSE,
1175                                                            GTK_PARAM_READWRITE));
1176
1177     g_object_class_install_property (o_class,
1178                                      PROP_TOOLTIP_COLUMN,
1179                                      g_param_spec_int ("tooltip-column",
1180                                                        P_("Tooltip Column"),
1181                                                        P_("The column in the model containing the tooltip texts for the rows"),
1182                                                        -1,
1183                                                        G_MAXINT,
1184                                                        -1,
1185                                                        GTK_PARAM_READWRITE));
1186
1187   /* Style properties */
1188 #define _TREE_VIEW_EXPANDER_SIZE 14
1189 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
1190 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
1191
1192   gtk_widget_class_install_style_property (widget_class,
1193                                            g_param_spec_int ("expander-size",
1194                                                              P_("Expander Size"),
1195                                                              P_("Size of the expander arrow"),
1196                                                              0,
1197                                                              G_MAXINT,
1198                                                              _TREE_VIEW_EXPANDER_SIZE,
1199                                                              GTK_PARAM_READABLE));
1200
1201   gtk_widget_class_install_style_property (widget_class,
1202                                            g_param_spec_int ("vertical-separator",
1203                                                              P_("Vertical Separator Width"),
1204                                                              P_("Vertical space between cells.  Must be an even number"),
1205                                                              0,
1206                                                              G_MAXINT,
1207                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
1208                                                              GTK_PARAM_READABLE));
1209
1210   gtk_widget_class_install_style_property (widget_class,
1211                                            g_param_spec_int ("horizontal-separator",
1212                                                              P_("Horizontal Separator Width"),
1213                                                              P_("Horizontal space between cells.  Must be an even number"),
1214                                                              0,
1215                                                              G_MAXINT,
1216                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
1217                                                              GTK_PARAM_READABLE));
1218
1219   gtk_widget_class_install_style_property (widget_class,
1220                                            g_param_spec_boolean ("allow-rules",
1221                                                                  P_("Allow Rules"),
1222                                                                  P_("Allow drawing of alternating color rows"),
1223                                                                  TRUE,
1224                                                                  GTK_PARAM_READABLE));
1225
1226   gtk_widget_class_install_style_property (widget_class,
1227                                            g_param_spec_boolean ("indent-expanders",
1228                                                                  P_("Indent Expanders"),
1229                                                                  P_("Make the expanders indented"),
1230                                                                  TRUE,
1231                                                                  GTK_PARAM_READABLE));
1232
1233   gtk_widget_class_install_style_property (widget_class,
1234                                            g_param_spec_boxed ("even-row-color",
1235                                                                P_("Even Row Color"),
1236                                                                P_("Color to use for even rows"),
1237                                                                GDK_TYPE_COLOR,
1238                                                                GTK_PARAM_READABLE));
1239
1240   gtk_widget_class_install_style_property (widget_class,
1241                                            g_param_spec_boxed ("odd-row-color",
1242                                                                P_("Odd Row Color"),
1243                                                                P_("Color to use for odd rows"),
1244                                                                GDK_TYPE_COLOR,
1245                                                                GTK_PARAM_READABLE));
1246
1247   gtk_widget_class_install_style_property (widget_class,
1248                                            g_param_spec_int ("grid-line-width",
1249                                                              P_("Grid line width"),
1250                                                              P_("Width, in pixels, of the tree view grid lines"),
1251                                                              0, G_MAXINT, 1,
1252                                                              GTK_PARAM_READABLE));
1253
1254   gtk_widget_class_install_style_property (widget_class,
1255                                            g_param_spec_int ("tree-line-width",
1256                                                              P_("Tree line width"),
1257                                                              P_("Width, in pixels, of the tree view lines"),
1258                                                              0, G_MAXINT, 1,
1259                                                              GTK_PARAM_READABLE));
1260
1261   gtk_widget_class_install_style_property (widget_class,
1262                                            g_param_spec_string ("grid-line-pattern",
1263                                                                 P_("Grid line pattern"),
1264                                                                 P_("Dash pattern used to draw the tree view grid lines"),
1265                                                                 "\1\1",
1266                                                                 GTK_PARAM_READABLE));
1267
1268   gtk_widget_class_install_style_property (widget_class,
1269                                            g_param_spec_string ("tree-line-pattern",
1270                                                                 P_("Tree line pattern"),
1271                                                                 P_("Dash pattern used to draw the tree view lines"),
1272                                                                 "\1\1",
1273                                                                 GTK_PARAM_READABLE));
1274
1275   /* Signals */
1276   /**
1277    * GtkTreeView::row-activated:
1278    * @tree_view: the object on which the signal is emitted
1279    * @path: the #GtkTreePath for the activated row
1280    * @column: the #GtkTreeViewColumn in which the activation occurred
1281    *
1282    * The "row-activated" signal is emitted when the method
1283    * gtk_tree_view_row_activated() is called or the user double clicks
1284    * a treeview row. It is also emitted when a non-editable row is
1285    * selected and one of the keys: Space, Shift+Space, Return or
1286    * Enter is pressed.
1287    *
1288    * For selection handling refer to the <link linkend="TreeWidget">tree
1289    * widget conceptual overview</link> as well as #GtkTreeSelection.
1290    */
1291   tree_view_signals[ROW_ACTIVATED] =
1292     g_signal_new (I_("row-activated"),
1293                   G_TYPE_FROM_CLASS (o_class),
1294                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1295                   G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
1296                   NULL, NULL,
1297                   _gtk_marshal_VOID__BOXED_OBJECT,
1298                   G_TYPE_NONE, 2,
1299                   GTK_TYPE_TREE_PATH,
1300                   GTK_TYPE_TREE_VIEW_COLUMN);
1301
1302   /**
1303    * GtkTreeView::test-expand-row:
1304    * @tree_view: the object on which the signal is emitted
1305    * @iter: the tree iter of the row to expand
1306    * @path: a tree path that points to the row
1307    *
1308    * The given row is about to be expanded (show its children nodes). Use this
1309    * signal if you need to control the expandability of individual rows.
1310    *
1311    * Returns: %FALSE to allow expansion, %TRUE to reject
1312    */
1313   tree_view_signals[TEST_EXPAND_ROW] =
1314     g_signal_new (I_("test-expand-row"),
1315                   G_TYPE_FROM_CLASS (o_class),
1316                   G_SIGNAL_RUN_LAST,
1317                   G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
1318                   _gtk_boolean_handled_accumulator, NULL,
1319                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1320                   G_TYPE_BOOLEAN, 2,
1321                   GTK_TYPE_TREE_ITER,
1322                   GTK_TYPE_TREE_PATH);
1323
1324   /**
1325    * GtkTreeView::test-collapse-row:
1326    * @tree_view: the object on which the signal is emitted
1327    * @iter: the tree iter of the row to collapse
1328    * @path: a tree path that points to the row
1329    *
1330    * The given row is about to be collapsed (hide its children nodes). Use this
1331    * signal if you need to control the collapsibility of individual rows.
1332    *
1333    * Returns: %FALSE to allow collapsing, %TRUE to reject
1334    */
1335   tree_view_signals[TEST_COLLAPSE_ROW] =
1336     g_signal_new (I_("test-collapse-row"),
1337                   G_TYPE_FROM_CLASS (o_class),
1338                   G_SIGNAL_RUN_LAST,
1339                   G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
1340                   _gtk_boolean_handled_accumulator, NULL,
1341                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1342                   G_TYPE_BOOLEAN, 2,
1343                   GTK_TYPE_TREE_ITER,
1344                   GTK_TYPE_TREE_PATH);
1345
1346   /**
1347    * GtkTreeView::row-expanded:
1348    * @tree_view: the object on which the signal is emitted
1349    * @iter: the tree iter of the expanded row
1350    * @path: a tree path that points to the row
1351    *
1352    * The given row has been expanded (child nodes are shown).
1353    */
1354   tree_view_signals[ROW_EXPANDED] =
1355     g_signal_new (I_("row-expanded"),
1356                   G_TYPE_FROM_CLASS (o_class),
1357                   G_SIGNAL_RUN_LAST,
1358                   G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
1359                   NULL, NULL,
1360                   _gtk_marshal_VOID__BOXED_BOXED,
1361                   G_TYPE_NONE, 2,
1362                   GTK_TYPE_TREE_ITER,
1363                   GTK_TYPE_TREE_PATH);
1364
1365   /**
1366    * GtkTreeView::row-collapsed:
1367    * @tree_view: the object on which the signal is emitted
1368    * @iter: the tree iter of the collapsed row
1369    * @path: a tree path that points to the row
1370    *
1371    * The given row has been collapsed (child nodes are hidden).
1372    */
1373   tree_view_signals[ROW_COLLAPSED] =
1374     g_signal_new (I_("row-collapsed"),
1375                   G_TYPE_FROM_CLASS (o_class),
1376                   G_SIGNAL_RUN_LAST,
1377                   G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
1378                   NULL, NULL,
1379                   _gtk_marshal_VOID__BOXED_BOXED,
1380                   G_TYPE_NONE, 2,
1381                   GTK_TYPE_TREE_ITER,
1382                   GTK_TYPE_TREE_PATH);
1383
1384   /**
1385    * GtkTreeView::columns-changed:
1386    * @tree_view: the object on which the signal is emitted
1387    *
1388    * The number of columns of the treeview has changed.
1389    */
1390   tree_view_signals[COLUMNS_CHANGED] =
1391     g_signal_new (I_("columns-changed"),
1392                   G_TYPE_FROM_CLASS (o_class),
1393                   G_SIGNAL_RUN_LAST,
1394                   G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
1395                   NULL, NULL,
1396                   _gtk_marshal_VOID__VOID,
1397                   G_TYPE_NONE, 0);
1398
1399   /**
1400    * GtkTreeView::cursor-changed:
1401    * @tree_view: the object on which the signal is emitted
1402    *
1403    * The position of the cursor (focused cell) has changed.
1404    */
1405   tree_view_signals[CURSOR_CHANGED] =
1406     g_signal_new (I_("cursor-changed"),
1407                   G_TYPE_FROM_CLASS (o_class),
1408                   G_SIGNAL_RUN_LAST,
1409                   G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
1410                   NULL, NULL,
1411                   _gtk_marshal_VOID__VOID,
1412                   G_TYPE_NONE, 0);
1413
1414   tree_view_signals[MOVE_CURSOR] =
1415     g_signal_new (I_("move-cursor"),
1416                   G_TYPE_FROM_CLASS (o_class),
1417                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1418                   G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
1419                   NULL, NULL,
1420                   _gtk_marshal_BOOLEAN__ENUM_INT,
1421                   G_TYPE_BOOLEAN, 2,
1422                   GTK_TYPE_MOVEMENT_STEP,
1423                   G_TYPE_INT);
1424
1425   tree_view_signals[SELECT_ALL] =
1426     g_signal_new (I_("select-all"),
1427                   G_TYPE_FROM_CLASS (o_class),
1428                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1429                   G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
1430                   NULL, NULL,
1431                   _gtk_marshal_BOOLEAN__VOID,
1432                   G_TYPE_BOOLEAN, 0);
1433
1434   tree_view_signals[UNSELECT_ALL] =
1435     g_signal_new (I_("unselect-all"),
1436                   G_TYPE_FROM_CLASS (o_class),
1437                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1438                   G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
1439                   NULL, NULL,
1440                   _gtk_marshal_BOOLEAN__VOID,
1441                   G_TYPE_BOOLEAN, 0);
1442
1443   tree_view_signals[SELECT_CURSOR_ROW] =
1444     g_signal_new (I_("select-cursor-row"),
1445                   G_TYPE_FROM_CLASS (o_class),
1446                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1447                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
1448                   NULL, NULL,
1449                   _gtk_marshal_BOOLEAN__BOOLEAN,
1450                   G_TYPE_BOOLEAN, 1,
1451                   G_TYPE_BOOLEAN);
1452
1453   tree_view_signals[TOGGLE_CURSOR_ROW] =
1454     g_signal_new (I_("toggle-cursor-row"),
1455                   G_TYPE_FROM_CLASS (o_class),
1456                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1457                   G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
1458                   NULL, NULL,
1459                   _gtk_marshal_BOOLEAN__VOID,
1460                   G_TYPE_BOOLEAN, 0);
1461
1462   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
1463     g_signal_new (I_("expand-collapse-cursor-row"),
1464                   G_TYPE_FROM_CLASS (o_class),
1465                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1466                   G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
1467                   NULL, NULL,
1468                   _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
1469                   G_TYPE_BOOLEAN, 3,
1470                   G_TYPE_BOOLEAN,
1471                   G_TYPE_BOOLEAN,
1472                   G_TYPE_BOOLEAN);
1473
1474   tree_view_signals[SELECT_CURSOR_PARENT] =
1475     g_signal_new (I_("select-cursor-parent"),
1476                   G_TYPE_FROM_CLASS (o_class),
1477                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1478                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
1479                   NULL, NULL,
1480                   _gtk_marshal_BOOLEAN__VOID,
1481                   G_TYPE_BOOLEAN, 0);
1482
1483   tree_view_signals[START_INTERACTIVE_SEARCH] =
1484     g_signal_new (I_("start-interactive-search"),
1485                   G_TYPE_FROM_CLASS (o_class),
1486                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1487                   G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
1488                   NULL, NULL,
1489                   _gtk_marshal_BOOLEAN__VOID,
1490                   G_TYPE_BOOLEAN, 0);
1491
1492   /* Key bindings */
1493   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Up, 0, TRUE,
1494                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1495   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Up, 0, TRUE,
1496                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1497
1498   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Down, 0, TRUE,
1499                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1500   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Down, 0, TRUE,
1501                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1502
1503   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_p, GDK_CONTROL_MASK, FALSE,
1504                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1505
1506   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_n, GDK_CONTROL_MASK, FALSE,
1507                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1508
1509   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Home, 0, TRUE,
1510                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1511   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Home, 0, TRUE,
1512                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1513
1514   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_End, 0, TRUE,
1515                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1516   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_End, 0, TRUE,
1517                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1518
1519   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Up, 0, TRUE,
1520                                   GTK_MOVEMENT_PAGES, -1);
1521   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0, TRUE,
1522                                   GTK_MOVEMENT_PAGES, -1);
1523
1524   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Down, 0, TRUE,
1525                                   GTK_MOVEMENT_PAGES, 1);
1526   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0, TRUE,
1527                                   GTK_MOVEMENT_PAGES, 1);
1528
1529
1530   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 0, "move-cursor", 2,
1531                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1532                                 G_TYPE_INT, 1);
1533
1534   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 0, "move-cursor", 2,
1535                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1536                                 G_TYPE_INT, -1);
1537
1538   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, 0, "move-cursor", 2,
1539                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1540                                 G_TYPE_INT, 1);
1541
1542   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, 0, "move-cursor", 2,
1543                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1544                                 G_TYPE_INT, -1);
1545
1546   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK,
1547                                 "move-cursor", 2,
1548                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1549                                 G_TYPE_INT, 1);
1550
1551   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
1552                                 "move-cursor", 2,
1553                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1554                                 G_TYPE_INT, -1);
1555
1556   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK,
1557                                 "move-cursor", 2,
1558                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1559                                 G_TYPE_INT, 1);
1560
1561   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
1562                                 "move-cursor", 2,
1563                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1564                                 G_TYPE_INT, -1);
1565
1566   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1567   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1568
1569   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK, "select-all", 0);
1570   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK, "select-all", 0);
1571
1572   gtk_binding_entry_add_signal (binding_set, GDK_KEY_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1573   gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1574
1575   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1576                                 G_TYPE_BOOLEAN, TRUE);
1577   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1578                                 G_TYPE_BOOLEAN, TRUE);
1579
1580   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0, "select-cursor-row", 1,
1581                                 G_TYPE_BOOLEAN, TRUE);
1582   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0, "select-cursor-row", 1,
1583                                 G_TYPE_BOOLEAN, TRUE);
1584   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0, "select-cursor-row", 1,
1585                                 G_TYPE_BOOLEAN, TRUE);
1586   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0, "select-cursor-row", 1,
1587                                 G_TYPE_BOOLEAN, TRUE);
1588   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0, "select-cursor-row", 1,
1589                                 G_TYPE_BOOLEAN, TRUE);
1590
1591   /* expand and collapse rows */
1592   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, 0, "expand-collapse-cursor-row", 3,
1593                                 G_TYPE_BOOLEAN, TRUE,
1594                                 G_TYPE_BOOLEAN, TRUE,
1595                                 G_TYPE_BOOLEAN, FALSE);
1596
1597   gtk_binding_entry_add_signal (binding_set, GDK_KEY_asterisk, 0,
1598                                 "expand-collapse-cursor-row", 3,
1599                                 G_TYPE_BOOLEAN, TRUE,
1600                                 G_TYPE_BOOLEAN, TRUE,
1601                                 G_TYPE_BOOLEAN, TRUE);
1602   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Multiply, 0,
1603                                 "expand-collapse-cursor-row", 3,
1604                                 G_TYPE_BOOLEAN, TRUE,
1605                                 G_TYPE_BOOLEAN, TRUE,
1606                                 G_TYPE_BOOLEAN, TRUE);
1607
1608   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, 0,
1609                                 "expand-collapse-cursor-row", 3,
1610                                 G_TYPE_BOOLEAN, TRUE,
1611                                 G_TYPE_BOOLEAN, FALSE,
1612                                 G_TYPE_BOOLEAN, FALSE);
1613   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Divide, 0,
1614                                 "expand-collapse-cursor-row", 3,
1615                                 G_TYPE_BOOLEAN, TRUE,
1616                                 G_TYPE_BOOLEAN, FALSE,
1617                                 G_TYPE_BOOLEAN, FALSE);
1618
1619   /* Not doable on US keyboards */
1620   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1621                                 G_TYPE_BOOLEAN, TRUE,
1622                                 G_TYPE_BOOLEAN, TRUE,
1623                                 G_TYPE_BOOLEAN, TRUE);
1624   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, 0, "expand-collapse-cursor-row", 3,
1625                                 G_TYPE_BOOLEAN, TRUE,
1626                                 G_TYPE_BOOLEAN, TRUE,
1627                                 G_TYPE_BOOLEAN, FALSE);
1628   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1629                                 G_TYPE_BOOLEAN, TRUE,
1630                                 G_TYPE_BOOLEAN, TRUE,
1631                                 G_TYPE_BOOLEAN, TRUE);
1632   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1633                                 G_TYPE_BOOLEAN, TRUE,
1634                                 G_TYPE_BOOLEAN, TRUE,
1635                                 G_TYPE_BOOLEAN, TRUE);
1636   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_SHIFT_MASK,
1637                                 "expand-collapse-cursor-row", 3,
1638                                 G_TYPE_BOOLEAN, FALSE,
1639                                 G_TYPE_BOOLEAN, TRUE,
1640                                 G_TYPE_BOOLEAN, TRUE);
1641   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_SHIFT_MASK,
1642                                 "expand-collapse-cursor-row", 3,
1643                                 G_TYPE_BOOLEAN, FALSE,
1644                                 G_TYPE_BOOLEAN, TRUE,
1645                                 G_TYPE_BOOLEAN, TRUE);
1646   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right,
1647                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1648                                 "expand-collapse-cursor-row", 3,
1649                                 G_TYPE_BOOLEAN, FALSE,
1650                                 G_TYPE_BOOLEAN, TRUE,
1651                                 G_TYPE_BOOLEAN, TRUE);
1652   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right,
1653                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1654                                 "expand-collapse-cursor-row", 3,
1655                                 G_TYPE_BOOLEAN, FALSE,
1656                                 G_TYPE_BOOLEAN, TRUE,
1657                                 G_TYPE_BOOLEAN, TRUE);
1658
1659   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, 0, "expand-collapse-cursor-row", 3,
1660                                 G_TYPE_BOOLEAN, TRUE,
1661                                 G_TYPE_BOOLEAN, FALSE,
1662                                 G_TYPE_BOOLEAN, FALSE);
1663   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1664                                 G_TYPE_BOOLEAN, TRUE,
1665                                 G_TYPE_BOOLEAN, FALSE,
1666                                 G_TYPE_BOOLEAN, TRUE);
1667   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, 0, "expand-collapse-cursor-row", 3,
1668                                 G_TYPE_BOOLEAN, TRUE,
1669                                 G_TYPE_BOOLEAN, FALSE,
1670                                 G_TYPE_BOOLEAN, FALSE);
1671   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1672                                 G_TYPE_BOOLEAN, TRUE,
1673                                 G_TYPE_BOOLEAN, FALSE,
1674                                 G_TYPE_BOOLEAN, TRUE);
1675   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_SHIFT_MASK,
1676                                 "expand-collapse-cursor-row", 3,
1677                                 G_TYPE_BOOLEAN, FALSE,
1678                                 G_TYPE_BOOLEAN, FALSE,
1679                                 G_TYPE_BOOLEAN, TRUE);
1680   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_SHIFT_MASK,
1681                                 "expand-collapse-cursor-row", 3,
1682                                 G_TYPE_BOOLEAN, FALSE,
1683                                 G_TYPE_BOOLEAN, FALSE,
1684                                 G_TYPE_BOOLEAN, TRUE);
1685   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left,
1686                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1687                                 "expand-collapse-cursor-row", 3,
1688                                 G_TYPE_BOOLEAN, FALSE,
1689                                 G_TYPE_BOOLEAN, FALSE,
1690                                 G_TYPE_BOOLEAN, TRUE);
1691   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left,
1692                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1693                                 "expand-collapse-cursor-row", 3,
1694                                 G_TYPE_BOOLEAN, FALSE,
1695                                 G_TYPE_BOOLEAN, FALSE,
1696                                 G_TYPE_BOOLEAN, TRUE);
1697
1698   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, 0, "select-cursor-parent", 0);
1699   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1700
1701   gtk_binding_entry_add_signal (binding_set, GDK_KEY_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1702
1703   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1704
1705   g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
1706
1707   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TREE_VIEW_ACCESSIBLE);
1708 }
1709
1710 static void
1711 gtk_tree_view_init (GtkTreeView *tree_view)
1712 {
1713   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
1714
1715   gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
1716   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1717
1718   tree_view->priv->show_expanders = TRUE;
1719   tree_view->priv->draw_keyfocus = TRUE;
1720   tree_view->priv->headers_visible = TRUE;
1721
1722   /* We need some padding */
1723   tree_view->priv->dy = 0;
1724   tree_view->priv->cursor_offset = 0;
1725   tree_view->priv->n_columns = 0;
1726   tree_view->priv->header_height = 1;
1727   tree_view->priv->x_drag = 0;
1728   tree_view->priv->drag_pos = -1;
1729   tree_view->priv->header_has_focus = FALSE;
1730   tree_view->priv->pressed_button = -1;
1731   tree_view->priv->press_start_x = -1;
1732   tree_view->priv->press_start_y = -1;
1733   tree_view->priv->reorderable = FALSE;
1734   tree_view->priv->presize_handler_timer = 0;
1735   tree_view->priv->scroll_sync_timer = 0;
1736   tree_view->priv->fixed_height = -1;
1737   tree_view->priv->fixed_height_mode = FALSE;
1738   tree_view->priv->fixed_height_check = 0;
1739   tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
1740   tree_view->priv->enable_search = TRUE;
1741   tree_view->priv->search_column = -1;
1742   tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
1743   tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
1744   tree_view->priv->search_custom_entry_set = FALSE;
1745   tree_view->priv->typeselect_flush_timeout = 0;
1746   tree_view->priv->init_hadjust_value = TRUE;
1747   tree_view->priv->width = 0;
1748
1749   tree_view->priv->hover_selection = FALSE;
1750   tree_view->priv->hover_expand = FALSE;
1751
1752   tree_view->priv->level_indentation = 0;
1753
1754   tree_view->priv->rubber_banding_enable = FALSE;
1755
1756   tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
1757   tree_view->priv->tree_lines_enabled = FALSE;
1758
1759   tree_view->priv->tooltip_column = -1;
1760
1761   tree_view->priv->post_validation_flag = FALSE;
1762
1763   tree_view->priv->last_button_x = -1;
1764   tree_view->priv->last_button_y = -1;
1765
1766   tree_view->priv->event_last_x = -10000;
1767   tree_view->priv->event_last_y = -10000;
1768
1769   gtk_tree_view_do_set_vadjustment (tree_view, NULL);
1770   gtk_tree_view_do_set_hadjustment (tree_view, NULL);
1771 }
1772
1773 \f
1774
1775 /* GObject Methods
1776  */
1777
1778 static void
1779 gtk_tree_view_set_property (GObject         *object,
1780                             guint            prop_id,
1781                             const GValue    *value,
1782                             GParamSpec      *pspec)
1783 {
1784   GtkTreeView *tree_view;
1785
1786   tree_view = GTK_TREE_VIEW (object);
1787
1788   switch (prop_id)
1789     {
1790     case PROP_MODEL:
1791       gtk_tree_view_set_model (tree_view, g_value_get_object (value));
1792       break;
1793     case PROP_HADJUSTMENT:
1794       gtk_tree_view_do_set_hadjustment (tree_view, g_value_get_object (value));
1795       break;
1796     case PROP_VADJUSTMENT:
1797       gtk_tree_view_do_set_vadjustment (tree_view, g_value_get_object (value));
1798       break;
1799     case PROP_HSCROLL_POLICY:
1800       tree_view->priv->hscroll_policy = g_value_get_enum (value);
1801       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1802       break;
1803     case PROP_VSCROLL_POLICY:
1804       tree_view->priv->vscroll_policy = g_value_get_enum (value);
1805       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1806       break;
1807     case PROP_HEADERS_VISIBLE:
1808       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1809       break;
1810     case PROP_HEADERS_CLICKABLE:
1811       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1812       break;
1813     case PROP_EXPANDER_COLUMN:
1814       gtk_tree_view_set_expander_column (tree_view, g_value_get_object (value));
1815       break;
1816     case PROP_REORDERABLE:
1817       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
1818       break;
1819     case PROP_RULES_HINT:
1820       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1821       break;
1822     case PROP_ENABLE_SEARCH:
1823       gtk_tree_view_set_enable_search (tree_view, g_value_get_boolean (value));
1824       break;
1825     case PROP_SEARCH_COLUMN:
1826       gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
1827       break;
1828     case PROP_FIXED_HEIGHT_MODE:
1829       gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
1830       break;
1831     case PROP_HOVER_SELECTION:
1832       tree_view->priv->hover_selection = g_value_get_boolean (value);
1833       break;
1834     case PROP_HOVER_EXPAND:
1835       tree_view->priv->hover_expand = g_value_get_boolean (value);
1836       break;
1837     case PROP_SHOW_EXPANDERS:
1838       gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
1839       break;
1840     case PROP_LEVEL_INDENTATION:
1841       tree_view->priv->level_indentation = g_value_get_int (value);
1842       break;
1843     case PROP_RUBBER_BANDING:
1844       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1845       break;
1846     case PROP_ENABLE_GRID_LINES:
1847       gtk_tree_view_set_grid_lines (tree_view, g_value_get_enum (value));
1848       break;
1849     case PROP_ENABLE_TREE_LINES:
1850       gtk_tree_view_set_enable_tree_lines (tree_view, g_value_get_boolean (value));
1851       break;
1852     case PROP_TOOLTIP_COLUMN:
1853       gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
1854       break;
1855     default:
1856       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1857       break;
1858     }
1859 }
1860
1861 static void
1862 gtk_tree_view_get_property (GObject    *object,
1863                             guint       prop_id,
1864                             GValue     *value,
1865                             GParamSpec *pspec)
1866 {
1867   GtkTreeView *tree_view;
1868
1869   tree_view = GTK_TREE_VIEW (object);
1870
1871   switch (prop_id)
1872     {
1873     case PROP_MODEL:
1874       g_value_set_object (value, tree_view->priv->model);
1875       break;
1876     case PROP_HADJUSTMENT:
1877       g_value_set_object (value, tree_view->priv->hadjustment);
1878       break;
1879     case PROP_VADJUSTMENT:
1880       g_value_set_object (value, tree_view->priv->vadjustment);
1881       break;
1882     case PROP_HSCROLL_POLICY:
1883       g_value_set_enum (value, tree_view->priv->hscroll_policy);
1884       break;
1885     case PROP_VSCROLL_POLICY:
1886       g_value_set_enum (value, tree_view->priv->vscroll_policy);
1887       break;
1888     case PROP_HEADERS_VISIBLE:
1889       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
1890       break;
1891     case PROP_HEADERS_CLICKABLE:
1892       g_value_set_boolean (value, gtk_tree_view_get_headers_clickable (tree_view));
1893       break;
1894     case PROP_EXPANDER_COLUMN:
1895       g_value_set_object (value, tree_view->priv->expander_column);
1896       break;
1897     case PROP_REORDERABLE:
1898       g_value_set_boolean (value, tree_view->priv->reorderable);
1899       break;
1900     case PROP_RULES_HINT:
1901       g_value_set_boolean (value, tree_view->priv->has_rules);
1902       break;
1903     case PROP_ENABLE_SEARCH:
1904       g_value_set_boolean (value, tree_view->priv->enable_search);
1905       break;
1906     case PROP_SEARCH_COLUMN:
1907       g_value_set_int (value, tree_view->priv->search_column);
1908       break;
1909     case PROP_FIXED_HEIGHT_MODE:
1910       g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
1911       break;
1912     case PROP_HOVER_SELECTION:
1913       g_value_set_boolean (value, tree_view->priv->hover_selection);
1914       break;
1915     case PROP_HOVER_EXPAND:
1916       g_value_set_boolean (value, tree_view->priv->hover_expand);
1917       break;
1918     case PROP_SHOW_EXPANDERS:
1919       g_value_set_boolean (value, tree_view->priv->show_expanders);
1920       break;
1921     case PROP_LEVEL_INDENTATION:
1922       g_value_set_int (value, tree_view->priv->level_indentation);
1923       break;
1924     case PROP_RUBBER_BANDING:
1925       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1926       break;
1927     case PROP_ENABLE_GRID_LINES:
1928       g_value_set_enum (value, tree_view->priv->grid_lines);
1929       break;
1930     case PROP_ENABLE_TREE_LINES:
1931       g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
1932       break;
1933     case PROP_TOOLTIP_COLUMN:
1934       g_value_set_int (value, tree_view->priv->tooltip_column);
1935       break;
1936     default:
1937       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1938       break;
1939     }
1940 }
1941
1942 static void
1943 gtk_tree_view_finalize (GObject *object)
1944 {
1945   G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
1946 }
1947
1948
1949 static GtkBuildableIface *parent_buildable_iface;
1950
1951 static void
1952 gtk_tree_view_buildable_init (GtkBuildableIface *iface)
1953 {
1954   parent_buildable_iface = g_type_interface_peek_parent (iface);
1955   iface->add_child = gtk_tree_view_buildable_add_child;
1956   iface->get_internal_child = gtk_tree_view_buildable_get_internal_child;
1957 }
1958
1959 static void
1960 gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
1961                                    GtkBuilder  *builder,
1962                                    GObject     *child,
1963                                    const gchar *type)
1964 {
1965   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (child));
1966 }
1967
1968 static GObject *
1969 gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
1970                                             GtkBuilder        *builder,
1971                                             const gchar       *childname)
1972 {
1973     if (strcmp (childname, "selection") == 0)
1974       return G_OBJECT (GTK_TREE_VIEW (buildable)->priv->selection);
1975
1976     return parent_buildable_iface->get_internal_child (buildable,
1977                                                        builder,
1978                                                        childname);
1979 }
1980
1981 /* GtkWidget Methods
1982  */
1983
1984 static void
1985 gtk_tree_view_free_rbtree (GtkTreeView *tree_view)
1986 {
1987   _gtk_rbtree_free (tree_view->priv->tree);
1988
1989   tree_view->priv->tree = NULL;
1990   tree_view->priv->button_pressed_node = NULL;
1991   tree_view->priv->button_pressed_tree = NULL;
1992   tree_view->priv->prelight_tree = NULL;
1993   tree_view->priv->prelight_node = NULL;
1994   tree_view->priv->expanded_collapsed_node = NULL;
1995   tree_view->priv->expanded_collapsed_tree = NULL;
1996 }
1997
1998 static void
1999 gtk_tree_view_destroy (GtkWidget *widget)
2000 {
2001   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2002   GList *list;
2003
2004   gtk_tree_view_stop_editing (tree_view, TRUE);
2005
2006   if (tree_view->priv->columns != NULL)
2007     {
2008       list = tree_view->priv->columns;
2009       while (list)
2010         {
2011           GtkTreeViewColumn *column;
2012           column = GTK_TREE_VIEW_COLUMN (list->data);
2013           list = list->next;
2014           gtk_tree_view_remove_column (tree_view, column);
2015         }
2016       tree_view->priv->columns = NULL;
2017     }
2018
2019   if (tree_view->priv->tree != NULL)
2020     {
2021       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
2022
2023       gtk_tree_view_free_rbtree (tree_view);
2024     }
2025
2026   if (tree_view->priv->selection != NULL)
2027     {
2028       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
2029       g_object_unref (tree_view->priv->selection);
2030       tree_view->priv->selection = NULL;
2031     }
2032
2033   if (tree_view->priv->scroll_to_path != NULL)
2034     {
2035       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
2036       tree_view->priv->scroll_to_path = NULL;
2037     }
2038
2039   if (tree_view->priv->drag_dest_row != NULL)
2040     {
2041       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
2042       tree_view->priv->drag_dest_row = NULL;
2043     }
2044
2045   if (tree_view->priv->top_row != NULL)
2046     {
2047       gtk_tree_row_reference_free (tree_view->priv->top_row);
2048       tree_view->priv->top_row = NULL;
2049     }
2050
2051   if (tree_view->priv->column_drop_func_data &&
2052       tree_view->priv->column_drop_func_data_destroy)
2053     {
2054       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
2055       tree_view->priv->column_drop_func_data = NULL;
2056     }
2057
2058   if (tree_view->priv->destroy_count_destroy &&
2059       tree_view->priv->destroy_count_data)
2060     {
2061       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
2062       tree_view->priv->destroy_count_data = NULL;
2063     }
2064
2065   gtk_tree_row_reference_free (tree_view->priv->anchor);
2066   tree_view->priv->anchor = NULL;
2067
2068   /* destroy interactive search dialog */
2069   if (tree_view->priv->search_window)
2070     {
2071       gtk_widget_destroy (tree_view->priv->search_window);
2072       tree_view->priv->search_window = NULL;
2073       tree_view->priv->search_entry = NULL;
2074       if (tree_view->priv->typeselect_flush_timeout)
2075         {
2076           g_source_remove (tree_view->priv->typeselect_flush_timeout);
2077           tree_view->priv->typeselect_flush_timeout = 0;
2078         }
2079     }
2080
2081   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
2082     {
2083       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
2084       tree_view->priv->search_user_data = NULL;
2085     }
2086
2087   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
2088     {
2089       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
2090       tree_view->priv->search_position_user_data = NULL;
2091     }
2092
2093   if (tree_view->priv->row_separator_destroy && tree_view->priv->row_separator_data)
2094     {
2095       tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
2096       tree_view->priv->row_separator_data = NULL;
2097     }
2098
2099   gtk_tree_view_set_model (tree_view, NULL);
2100
2101   if (tree_view->priv->hadjustment)
2102     {
2103       g_object_unref (tree_view->priv->hadjustment);
2104       tree_view->priv->hadjustment = NULL;
2105     }
2106   if (tree_view->priv->vadjustment)
2107     {
2108       g_object_unref (tree_view->priv->vadjustment);
2109       tree_view->priv->vadjustment = NULL;
2110     }
2111
2112   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->destroy (widget);
2113 }
2114
2115 /* GtkWidget::map helper */
2116 static void
2117 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
2118 {
2119   GList *list;
2120
2121   g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
2122
2123   if (tree_view->priv->headers_visible)
2124     {
2125       GtkTreeViewColumn *column;
2126       GtkWidget         *button;
2127       GdkWindow         *window;
2128
2129       for (list = tree_view->priv->columns; list; list = list->next)
2130         {
2131           column = list->data;
2132           button = gtk_tree_view_column_get_button (column);
2133
2134           if (gtk_tree_view_column_get_visible (column) && button)
2135             gtk_widget_show_now (button);
2136
2137           if (gtk_widget_get_visible (button) &&
2138               !gtk_widget_get_mapped (button))
2139             gtk_widget_map (button);
2140         }
2141       for (list = tree_view->priv->columns; list; list = list->next)
2142         {
2143           column = list->data;
2144           if (gtk_tree_view_column_get_visible (column) == FALSE)
2145             continue;
2146
2147           window = _gtk_tree_view_column_get_window (column);
2148           if (gtk_tree_view_column_get_resizable (column))
2149             {
2150               gdk_window_raise (window);
2151               gdk_window_show (window);
2152             }
2153           else
2154             gdk_window_hide (window);
2155         }
2156       gdk_window_show (tree_view->priv->header_window);
2157     }
2158 }
2159
2160 static void
2161 gtk_tree_view_map (GtkWidget *widget)
2162 {
2163   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2164   GList *tmp_list;
2165
2166   gtk_widget_set_mapped (widget, TRUE);
2167
2168   tmp_list = tree_view->priv->children;
2169   while (tmp_list)
2170     {
2171       GtkTreeViewChild *child = tmp_list->data;
2172       tmp_list = tmp_list->next;
2173
2174       if (gtk_widget_get_visible (child->widget))
2175         {
2176           if (!gtk_widget_get_mapped (child->widget))
2177             gtk_widget_map (child->widget);
2178         }
2179     }
2180   gdk_window_show (tree_view->priv->bin_window);
2181
2182   gtk_tree_view_map_buttons (tree_view);
2183
2184   gdk_window_show (gtk_widget_get_window (widget));
2185 }
2186
2187 static void
2188 gtk_tree_view_ensure_background (GtkTreeView *tree_view)
2189 {
2190   GtkStyleContext *context;
2191
2192   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
2193
2194   gtk_style_context_save (context);
2195   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
2196   gtk_style_context_set_background (context, tree_view->priv->bin_window);
2197   gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view)));
2198   gtk_style_context_restore (context);
2199
2200   gtk_style_context_set_background (context, tree_view->priv->header_window);
2201 }
2202
2203 static void
2204 gtk_tree_view_realize (GtkWidget *widget)
2205 {
2206   GtkAllocation allocation;
2207   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2208   GdkWindow *window;
2209   GdkWindowAttr attributes;
2210   GList *tmp_list;
2211   gint attributes_mask;
2212
2213   gtk_widget_set_realized (widget, TRUE);
2214
2215   gtk_widget_get_allocation (widget, &allocation);
2216
2217   /* Make the main, clipping window */
2218   attributes.window_type = GDK_WINDOW_CHILD;
2219   attributes.x = allocation.x;
2220   attributes.y = allocation.y;
2221   attributes.width = allocation.width;
2222   attributes.height = allocation.height;
2223   attributes.wclass = GDK_INPUT_OUTPUT;
2224   attributes.visual = gtk_widget_get_visual (widget);
2225   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
2226
2227   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
2228
2229   window = gdk_window_new (gtk_widget_get_parent_window (widget),
2230                            &attributes, attributes_mask);
2231   gtk_widget_set_window (widget, window);
2232   gdk_window_set_user_data (window, widget);
2233
2234   gtk_widget_get_allocation (widget, &allocation);
2235
2236   /* Make the window for the tree */
2237   attributes.x = 0;
2238   attributes.y = gtk_tree_view_get_effective_header_height (tree_view);
2239   attributes.width = MAX (tree_view->priv->width, allocation.width);
2240   attributes.height = allocation.height;
2241   attributes.event_mask = (GDK_EXPOSURE_MASK |
2242                            GDK_SCROLL_MASK |
2243                            GDK_SMOOTH_SCROLL_MASK |
2244                            GDK_POINTER_MOTION_MASK |
2245                            GDK_ENTER_NOTIFY_MASK |
2246                            GDK_LEAVE_NOTIFY_MASK |
2247                            GDK_BUTTON_PRESS_MASK |
2248                            GDK_BUTTON_RELEASE_MASK |
2249                            gtk_widget_get_events (widget));
2250
2251   tree_view->priv->bin_window = gdk_window_new (window,
2252                                                 &attributes, attributes_mask);
2253   gdk_window_set_user_data (tree_view->priv->bin_window, widget);
2254
2255   gtk_widget_get_allocation (widget, &allocation);
2256
2257   /* Make the column header window */
2258   attributes.x = 0;
2259   attributes.y = 0;
2260   attributes.width = MAX (tree_view->priv->width, allocation.width);
2261   attributes.height = tree_view->priv->header_height;
2262   attributes.event_mask = (GDK_EXPOSURE_MASK |
2263                            GDK_SCROLL_MASK |
2264                            GDK_ENTER_NOTIFY_MASK |
2265                            GDK_LEAVE_NOTIFY_MASK |
2266                            GDK_BUTTON_PRESS_MASK |
2267                            GDK_BUTTON_RELEASE_MASK |
2268                            GDK_KEY_PRESS_MASK |
2269                            GDK_KEY_RELEASE_MASK |
2270                            gtk_widget_get_events (widget));
2271
2272   tree_view->priv->header_window = gdk_window_new (window,
2273                                                    &attributes, attributes_mask);
2274   gdk_window_set_user_data (tree_view->priv->header_window, widget);
2275
2276   gtk_tree_view_ensure_background (tree_view);
2277
2278   tmp_list = tree_view->priv->children;
2279   while (tmp_list)
2280     {
2281       GtkTreeViewChild *child = tmp_list->data;
2282       tmp_list = tmp_list->next;
2283
2284       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
2285     }
2286
2287   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2288     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
2289
2290   /* Need to call those here, since they create GCs */
2291   gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
2292   gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
2293
2294   install_presize_handler (tree_view);
2295 }
2296
2297 static void
2298 gtk_tree_view_unrealize (GtkWidget *widget)
2299 {
2300   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2301   GtkTreeViewPrivate *priv = tree_view->priv;
2302   GList *list;
2303
2304   if (priv->scroll_timeout != 0)
2305     {
2306       g_source_remove (priv->scroll_timeout);
2307       priv->scroll_timeout = 0;
2308     }
2309
2310   if (priv->auto_expand_timeout != 0)
2311     {
2312       g_source_remove (priv->auto_expand_timeout);
2313       priv->auto_expand_timeout = 0;
2314     }
2315
2316   if (priv->open_dest_timeout != 0)
2317     {
2318       g_source_remove (priv->open_dest_timeout);
2319       priv->open_dest_timeout = 0;
2320     }
2321
2322   if (priv->presize_handler_timer != 0)
2323     {
2324       g_source_remove (priv->presize_handler_timer);
2325       priv->presize_handler_timer = 0;
2326     }
2327
2328   if (priv->validate_rows_timer != 0)
2329     {
2330       g_source_remove (priv->validate_rows_timer);
2331       priv->validate_rows_timer = 0;
2332     }
2333
2334   if (priv->scroll_sync_timer != 0)
2335     {
2336       g_source_remove (priv->scroll_sync_timer);
2337       priv->scroll_sync_timer = 0;
2338     }
2339
2340   if (priv->typeselect_flush_timeout)
2341     {
2342       g_source_remove (priv->typeselect_flush_timeout);
2343       priv->typeselect_flush_timeout = 0;
2344     }
2345
2346   for (list = priv->columns; list; list = list->next)
2347     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
2348
2349   gdk_window_set_user_data (priv->bin_window, NULL);
2350   gdk_window_destroy (priv->bin_window);
2351   priv->bin_window = NULL;
2352
2353   gdk_window_set_user_data (priv->header_window, NULL);
2354   gdk_window_destroy (priv->header_window);
2355   priv->header_window = NULL;
2356
2357   if (priv->drag_window)
2358     {
2359       gdk_window_set_user_data (priv->drag_window, NULL);
2360       gdk_window_destroy (priv->drag_window);
2361       priv->drag_window = NULL;
2362     }
2363
2364   if (priv->drag_highlight_window)
2365     {
2366       gdk_window_set_user_data (priv->drag_highlight_window, NULL);
2367       gdk_window_destroy (priv->drag_highlight_window);
2368       priv->drag_highlight_window = NULL;
2369     }
2370
2371   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
2372 }
2373
2374 /* GtkWidget::size_request helper */
2375 static void
2376 gtk_tree_view_size_request_columns (GtkTreeView *tree_view)
2377 {
2378   GList *list;
2379
2380   tree_view->priv->header_height = 0;
2381
2382   for (list = tree_view->priv->columns; list; list = list->next)
2383     {
2384       GtkRequisition     requisition;
2385       GtkTreeViewColumn *column = list->data;
2386       GtkWidget         *button = gtk_tree_view_column_get_button (column);
2387
2388       if (button == NULL)
2389         continue;
2390
2391       gtk_widget_get_preferred_size (button, &requisition, NULL);
2392       tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
2393     }
2394 }
2395
2396
2397 /* Called only by ::size_request */
2398 static void
2399 gtk_tree_view_update_size (GtkTreeView *tree_view)
2400 {
2401   GList *list;
2402   GtkTreeViewColumn *column;
2403   gint i;
2404
2405   if (tree_view->priv->model == NULL)
2406     {
2407       tree_view->priv->width = 0;
2408       tree_view->priv->prev_width = 0;
2409       tree_view->priv->height = 0;
2410       return;
2411     }
2412
2413   tree_view->priv->prev_width = tree_view->priv->width;
2414   tree_view->priv->width = 0;
2415
2416   /* keep this in sync with size_allocate below */
2417   for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
2418     {
2419       column = list->data;
2420       if (!gtk_tree_view_column_get_visible (column))
2421         continue;
2422
2423       tree_view->priv->width += _gtk_tree_view_column_request_width (column);
2424     }
2425
2426   if (tree_view->priv->tree == NULL)
2427     tree_view->priv->height = 0;
2428   else
2429     tree_view->priv->height = tree_view->priv->tree->root->offset;
2430 }
2431
2432 static void
2433 gtk_tree_view_size_request (GtkWidget      *widget,
2434                             GtkRequisition *requisition,
2435                             gboolean        may_validate)
2436 {
2437   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2438
2439   if (may_validate)
2440     {
2441       /* we validate some rows initially just to make sure we have some size.
2442        * In practice, with a lot of static lists, this should get a good width.
2443        */
2444       do_validate_rows (tree_view, FALSE);
2445     }
2446
2447   gtk_tree_view_size_request_columns (tree_view);
2448   gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
2449
2450   requisition->width = tree_view->priv->width;
2451   requisition->height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view);
2452 }
2453
2454 static void
2455 gtk_tree_view_get_preferred_width (GtkWidget *widget,
2456                                    gint      *minimum,
2457                                    gint      *natural)
2458 {
2459   GtkRequisition requisition;
2460
2461   gtk_tree_view_size_request (widget, &requisition, TRUE);
2462
2463   *minimum = *natural = requisition.width;
2464 }
2465
2466 static void
2467 gtk_tree_view_get_preferred_height (GtkWidget *widget,
2468                                     gint      *minimum,
2469                                     gint      *natural)
2470 {
2471   GtkRequisition requisition;
2472
2473   gtk_tree_view_size_request (widget, &requisition, TRUE);
2474
2475   *minimum = *natural = requisition.height;
2476 }
2477
2478 static int
2479 gtk_tree_view_calculate_width_before_expander (GtkTreeView *tree_view)
2480 {
2481   int width = 0;
2482   GList *list;
2483   gboolean rtl;
2484
2485   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2486   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2487        list->data != tree_view->priv->expander_column;
2488        list = (rtl ? list->prev : list->next))
2489     {
2490       GtkTreeViewColumn *column = list->data;
2491
2492       width += gtk_tree_view_column_get_width (column);
2493     }
2494
2495   return width;
2496 }
2497
2498 /* GtkWidget::size_allocate helper */
2499 static void
2500 gtk_tree_view_size_allocate_columns (GtkWidget *widget,
2501                                      gboolean  *width_changed)
2502 {
2503   GtkTreeView *tree_view;
2504   GList *list, *first_column, *last_column;
2505   GtkTreeViewColumn *column;
2506   GtkAllocation widget_allocation;
2507   gint width = 0;
2508   gint extra, extra_per_column, extra_for_last;
2509   gint full_requested_width = 0;
2510   gint number_of_expand_columns = 0;
2511   gboolean rtl;
2512   gboolean update_expand;
2513
2514   tree_view = GTK_TREE_VIEW (widget);
2515
2516   for (last_column = g_list_last (tree_view->priv->columns);
2517        last_column &&
2518        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
2519        last_column = last_column->prev)
2520     ;
2521   if (last_column == NULL)
2522     return;
2523
2524   for (first_column = g_list_first (tree_view->priv->columns);
2525        first_column &&
2526        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
2527        first_column = first_column->next)
2528     ;
2529
2530   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2531
2532   /* find out how many extra space and expandable columns we have */
2533   for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
2534     {
2535       column = (GtkTreeViewColumn *)list->data;
2536
2537       if (!gtk_tree_view_column_get_visible (column))
2538         continue;
2539
2540       full_requested_width += _gtk_tree_view_column_request_width (column);
2541
2542       if (gtk_tree_view_column_get_expand (column))
2543         number_of_expand_columns++;
2544     }
2545
2546   /* Only update the expand value if the width of the widget has changed,
2547    * or the number of expand columns has changed, or if there are no expand
2548    * columns, or if we didn't have an size-allocation yet after the
2549    * last validated node.
2550    */
2551   update_expand = (width_changed && *width_changed == TRUE)
2552       || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns
2553       || number_of_expand_columns == 0
2554       || tree_view->priv->post_validation_flag == TRUE;
2555
2556   tree_view->priv->post_validation_flag = FALSE;
2557
2558   gtk_widget_get_allocation (widget, &widget_allocation);
2559   if (!update_expand)
2560     {
2561       extra = tree_view->priv->last_extra_space;
2562       extra_for_last = MAX (widget_allocation.width - full_requested_width - extra, 0);
2563     }
2564   else
2565     {
2566       extra = MAX (widget_allocation.width - full_requested_width, 0);
2567       extra_for_last = 0;
2568
2569       tree_view->priv->last_extra_space = extra;
2570     }
2571
2572   if (number_of_expand_columns > 0)
2573     extra_per_column = extra/number_of_expand_columns;
2574   else
2575     extra_per_column = 0;
2576
2577   if (update_expand)
2578     {
2579       tree_view->priv->last_extra_space_per_column = extra_per_column;
2580       tree_view->priv->last_number_of_expand_columns = number_of_expand_columns;
2581     }
2582
2583   for (list = (rtl ? last_column : first_column);
2584        list != (rtl ? first_column->prev : last_column->next);
2585        list = (rtl ? list->prev : list->next))
2586     {
2587       gint column_width;
2588
2589       column = list->data;
2590
2591       if (!gtk_tree_view_column_get_visible (column))
2592         continue;
2593
2594       /* We need to handle the dragged button specially.
2595        */
2596       if (column == tree_view->priv->drag_column)
2597         {
2598           GtkAllocation drag_allocation;
2599           GtkWidget    *button;
2600
2601           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
2602
2603           drag_allocation.x = 0;
2604           drag_allocation.y = 0;
2605           drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
2606           drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
2607           gtk_widget_size_allocate (button, &drag_allocation);
2608           width += drag_allocation.width;
2609           continue;
2610         }
2611
2612       column_width = _gtk_tree_view_column_request_width (column);
2613
2614       if (gtk_tree_view_column_get_expand (column))
2615         {
2616           if (number_of_expand_columns == 1)
2617             {
2618               /* We add the remander to the last column as
2619                * */
2620               column_width += extra;
2621             }
2622           else
2623             {
2624               column_width += extra_per_column;
2625               extra -= extra_per_column;
2626               number_of_expand_columns --;
2627             }
2628         }
2629       else if (number_of_expand_columns == 0 &&
2630                list == last_column)
2631         {
2632           column_width += extra;
2633         }
2634
2635       /* In addition to expand, the last column can get even more
2636        * extra space so all available space is filled up.
2637        */
2638       if (extra_for_last > 0 && list == last_column)
2639         column_width += extra_for_last;
2640
2641       _gtk_tree_view_column_allocate (column, width, column_width);
2642
2643       width += column_width;
2644     }
2645
2646   /* We change the width here.  The user might have been resizing columns,
2647    * which changes the total width of the tree view.  This is of
2648    * importance for getting the horizontal scroll bar right.
2649    */
2650   if (tree_view->priv->width != width)
2651     {
2652       tree_view->priv->width = width;
2653       if (width_changed)
2654         *width_changed = TRUE;
2655     }
2656 }
2657
2658
2659 static void
2660 gtk_tree_view_size_allocate (GtkWidget     *widget,
2661                              GtkAllocation *allocation)
2662 {
2663   GtkAllocation widget_allocation;
2664   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2665   GList *tmp_list;
2666   gboolean width_changed = FALSE;
2667   gint old_width;
2668
2669   gtk_widget_get_allocation (widget, &widget_allocation);
2670   old_width = widget_allocation.width;
2671   if (allocation->width != widget_allocation.width)
2672     width_changed = TRUE;
2673
2674   gtk_widget_set_allocation (widget, allocation);
2675
2676   tmp_list = tree_view->priv->children;
2677
2678   while (tmp_list)
2679     {
2680       GtkAllocation allocation;
2681
2682       GtkTreeViewChild *child = tmp_list->data;
2683       tmp_list = tmp_list->next;
2684
2685       /* totally ignore our child's requisition */
2686       allocation.x = child->x;
2687       allocation.y = child->y;
2688       allocation.width = child->width;
2689       allocation.height = child->height;
2690       gtk_widget_size_allocate (child->widget, &allocation);
2691     }
2692
2693   /* We size-allocate the columns first because the width of the
2694    * tree view (used in updating the adjustments below) might change.
2695    */
2696   gtk_tree_view_size_allocate_columns (widget, &width_changed);
2697
2698   g_object_freeze_notify (G_OBJECT (tree_view->priv->hadjustment));
2699   gtk_adjustment_set_page_size (tree_view->priv->hadjustment,
2700                                 allocation->width);
2701   gtk_adjustment_set_page_increment (tree_view->priv->hadjustment,
2702                                      allocation->width * 0.9);
2703   gtk_adjustment_set_step_increment (tree_view->priv->hadjustment,
2704                                      allocation->width * 0.1);
2705   gtk_adjustment_set_lower (tree_view->priv->hadjustment, 0);
2706   gtk_adjustment_set_upper (tree_view->priv->hadjustment,
2707                             MAX (gtk_adjustment_get_page_size (tree_view->priv->hadjustment),
2708                                  tree_view->priv->width));
2709   g_object_thaw_notify (G_OBJECT (tree_view->priv->hadjustment));
2710
2711   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2712     {
2713       if (allocation->width < tree_view->priv->width)
2714         {
2715           if (tree_view->priv->init_hadjust_value)
2716             {
2717               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2718                                         MAX (tree_view->priv->width -
2719                                              allocation->width, 0));
2720               tree_view->priv->init_hadjust_value = FALSE;
2721             }
2722           else if (allocation->width != old_width)
2723             {
2724               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2725                                         CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) - allocation->width + old_width,
2726                                                0,
2727                                                tree_view->priv->width - allocation->width));
2728             }
2729           else
2730             gtk_adjustment_set_value (tree_view->priv->hadjustment,
2731                                       CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - gtk_adjustment_get_value (tree_view->priv->hadjustment)),
2732                                              0,
2733                                              tree_view->priv->width - allocation->width));
2734         }
2735       else
2736         {
2737           gtk_adjustment_set_value (tree_view->priv->hadjustment, 0);
2738           tree_view->priv->init_hadjust_value = TRUE;
2739         }
2740     }
2741   else
2742     if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + allocation->width > tree_view->priv->width)
2743       gtk_adjustment_set_value (tree_view->priv->hadjustment,
2744                                 MAX (tree_view->priv->width -
2745                                      allocation->width, 0));
2746
2747   g_object_freeze_notify (G_OBJECT (tree_view->priv->vadjustment));
2748   gtk_adjustment_set_page_size (tree_view->priv->vadjustment,
2749                                 allocation->height -
2750                                 gtk_tree_view_get_effective_header_height (tree_view));
2751   gtk_adjustment_set_step_increment (tree_view->priv->vadjustment,
2752                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.1);
2753   gtk_adjustment_set_page_increment (tree_view->priv->vadjustment,
2754                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.9);
2755   gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
2756   gtk_adjustment_set_upper (tree_view->priv->vadjustment,
2757                             MAX (gtk_adjustment_get_page_size (tree_view->priv->vadjustment),
2758                                  tree_view->priv->height));
2759   g_object_thaw_notify (G_OBJECT (tree_view->priv->vadjustment));
2760
2761   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2762   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
2763     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2764   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
2765     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2766                               tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
2767   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2768     gtk_tree_view_top_row_to_dy (tree_view);
2769   else
2770     gtk_tree_view_dy_to_top_row (tree_view);
2771
2772   if (gtk_widget_get_realized (widget))
2773     {
2774       gdk_window_move_resize (gtk_widget_get_window (widget),
2775                               allocation->x, allocation->y,
2776                               allocation->width, allocation->height);
2777       gdk_window_move_resize (tree_view->priv->header_window,
2778                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2779                               0,
2780                               MAX (tree_view->priv->width, allocation->width),
2781                               tree_view->priv->header_height);
2782       gdk_window_move_resize (tree_view->priv->bin_window,
2783                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2784                               gtk_tree_view_get_effective_header_height (tree_view),
2785                               MAX (tree_view->priv->width, allocation->width),
2786                               allocation->height - gtk_tree_view_get_effective_header_height (tree_view));
2787
2788       if (tree_view->priv->tree == NULL)
2789         invalidate_empty_focus (tree_view);
2790
2791       if (width_changed && tree_view->priv->expander_column)
2792         {
2793           /* Might seem awkward, but is the best heuristic I could come up
2794            * with.  Only if the width of the columns before the expander
2795            * changes, we will update the prelight status.  It is this
2796            * width that makes the expander move vertically.  Always updating
2797            * prelight status causes trouble with hover selections.
2798            */
2799           gint width_before_expander;
2800
2801           width_before_expander = gtk_tree_view_calculate_width_before_expander (tree_view);
2802
2803           if (tree_view->priv->prev_width_before_expander
2804               != width_before_expander)
2805               update_prelight (tree_view,
2806                                tree_view->priv->event_last_x,
2807                                tree_view->priv->event_last_y);
2808
2809           tree_view->priv->prev_width_before_expander = width_before_expander;
2810         }
2811     }
2812 }
2813
2814 /* Grabs the focus and unsets the GTK_TREE_VIEW_DRAW_KEYFOCUS flag */
2815 static void
2816 grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
2817 {
2818   GtkWidget *widget = GTK_WIDGET (tree_view);
2819
2820   if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
2821     gtk_widget_grab_focus (widget);
2822   tree_view->priv->draw_keyfocus = 0;
2823 }
2824
2825 static inline gboolean
2826 row_is_separator (GtkTreeView *tree_view,
2827                   GtkTreeIter *iter,
2828                   GtkTreePath *path)
2829 {
2830   gboolean is_separator = FALSE;
2831
2832   if (tree_view->priv->row_separator_func)
2833     {
2834       GtkTreeIter tmpiter;
2835
2836       if (iter)
2837         tmpiter = *iter;
2838       else
2839         {
2840           if (!gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path))
2841             return FALSE;
2842         }
2843
2844       is_separator = tree_view->priv->row_separator_func (tree_view->priv->model,
2845                                                           &tmpiter,
2846                                                           tree_view->priv->row_separator_data);
2847     }
2848
2849   return is_separator;
2850 }
2851
2852 static int
2853 gtk_tree_view_get_expander_size (GtkTreeView *tree_view)
2854 {
2855   gint expander_size;
2856
2857   gtk_widget_style_get (GTK_WIDGET (tree_view),
2858                         "expander-size", &expander_size,
2859                         NULL);
2860   expander_size += EXPANDER_EXTRA_PADDING;
2861
2862   return expander_size;
2863 }
2864
2865 static gboolean
2866 gtk_tree_view_button_press (GtkWidget      *widget,
2867                             GdkEventButton *event)
2868 {
2869   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2870   GList *list;
2871   GtkTreeViewColumn *column = NULL;
2872   gint i;
2873   GdkRectangle background_area;
2874   GdkRectangle cell_area;
2875   gint vertical_separator;
2876   gint horizontal_separator;
2877   gboolean path_is_selectable;
2878   gboolean rtl;
2879
2880   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2881   gtk_tree_view_stop_editing (tree_view, FALSE);
2882   gtk_widget_style_get (widget,
2883                         "vertical-separator", &vertical_separator,
2884                         "horizontal-separator", &horizontal_separator,
2885                         NULL);
2886
2887   /* Don't handle extra mouse buttons events, let them bubble up */
2888   if (event->button > 5)
2889     return FALSE;
2890
2891   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2892    * we're done handling the button press.
2893    */
2894
2895   if (event->window == tree_view->priv->bin_window)
2896     {
2897       GtkRBNode *node;
2898       GtkRBTree *tree;
2899       GtkTreePath *path;
2900       gint depth;
2901       gint new_y;
2902       gint y_offset;
2903       gint dval;
2904       gint pre_val, aft_val;
2905       GtkTreeViewColumn *column = NULL;
2906       gint column_handled_click = FALSE;
2907       gboolean row_double_click = FALSE;
2908       gboolean rtl;
2909       gboolean node_selected;
2910       GdkModifierType extend_mod_mask;
2911       GdkModifierType modify_mod_mask;
2912
2913       /* Empty tree? */
2914       if (tree_view->priv->tree == NULL)
2915         {
2916           grab_focus_and_unset_draw_keyfocus (tree_view);
2917           return TRUE;
2918         }
2919
2920       /* are we in an arrow? */
2921       if (tree_view->priv->prelight_node &&
2922           tree_view->priv->arrow_prelit &&
2923           gtk_tree_view_draw_expanders (tree_view))
2924         {
2925           if (event->button == GDK_BUTTON_PRIMARY)
2926             {
2927               gtk_grab_add (widget);
2928               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2929               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2930               gtk_tree_view_queue_draw_arrow (GTK_TREE_VIEW (widget),
2931                                               tree_view->priv->prelight_tree,
2932                                               tree_view->priv->prelight_node);
2933             }
2934
2935           grab_focus_and_unset_draw_keyfocus (tree_view);
2936           return TRUE;
2937         }
2938
2939       /* find the node that was clicked */
2940       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
2941       if (new_y < 0)
2942         new_y = 0;
2943       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
2944
2945       if (node == NULL)
2946         {
2947           /* We clicked in dead space */
2948           grab_focus_and_unset_draw_keyfocus (tree_view);
2949           return TRUE;
2950         }
2951
2952       /* Get the path and the node */
2953       path = _gtk_tree_path_new_from_rbtree (tree, node);
2954       path_is_selectable = !row_is_separator (tree_view, NULL, path);
2955
2956       if (!path_is_selectable)
2957         {
2958           gtk_tree_path_free (path);
2959           grab_focus_and_unset_draw_keyfocus (tree_view);
2960           return TRUE;
2961         }
2962
2963       depth = gtk_tree_path_get_depth (path);
2964       background_area.y = y_offset + event->y;
2965       background_area.height = gtk_tree_view_get_row_height (tree_view, node);
2966       background_area.x = 0;
2967
2968
2969       /* Let the column have a chance at selecting it. */
2970       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2971       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2972            list; list = (rtl ? list->prev : list->next))
2973         {
2974           GtkTreeViewColumn *candidate = list->data;
2975
2976           if (!gtk_tree_view_column_get_visible (candidate))
2977             continue;
2978
2979           background_area.width = gtk_tree_view_column_get_width (candidate);
2980           if ((background_area.x > (gint) event->x) ||
2981               (background_area.x + background_area.width <= (gint) event->x))
2982             {
2983               background_area.x += background_area.width;
2984               continue;
2985             }
2986
2987           /* we found the focus column */
2988           column = candidate;
2989           cell_area = background_area;
2990           cell_area.width -= horizontal_separator;
2991           cell_area.height -= vertical_separator;
2992           cell_area.x += horizontal_separator/2;
2993           cell_area.y += vertical_separator/2;
2994           if (gtk_tree_view_is_expander_column (tree_view, column))
2995             {
2996               if (!rtl)
2997                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
2998               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
2999
3000               if (gtk_tree_view_draw_expanders (tree_view))
3001                 {
3002                   gint expander_size = gtk_tree_view_get_expander_size (tree_view);
3003                   if (!rtl)
3004                     cell_area.x += depth * expander_size;
3005                   cell_area.width -= depth * expander_size;
3006                 }
3007             }
3008           break;
3009         }
3010
3011       if (column == NULL)
3012         {
3013           gtk_tree_path_free (path);
3014           grab_focus_and_unset_draw_keyfocus (tree_view);
3015           return FALSE;
3016         }
3017
3018       _gtk_tree_view_set_focus_column (tree_view, column);
3019
3020       /* decide if we edit */
3021       if (event->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_PRIMARY &&
3022           !(event->state & gtk_accelerator_get_default_mod_mask ()))
3023         {
3024           GtkTreePath *anchor;
3025           GtkTreeIter iter;
3026
3027           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
3028           gtk_tree_view_column_cell_set_cell_data (column,
3029                                                    tree_view->priv->model,
3030                                                    &iter,
3031                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
3032                                                    node->children?TRUE:FALSE);
3033
3034           if (tree_view->priv->anchor)
3035             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
3036           else
3037             anchor = NULL;
3038
3039           if ((anchor && !gtk_tree_path_compare (anchor, path))
3040               || !_gtk_tree_view_column_has_editable_cell (column))
3041             {
3042               GtkCellEditable *cell_editable = NULL;
3043
3044               /* FIXME: get the right flags */
3045               guint flags = 0;
3046
3047               if (_gtk_tree_view_column_cell_event (column,
3048                                                     (GdkEvent *)event,
3049                                                     &cell_area, flags))
3050                 {
3051                   GtkCellArea *area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
3052                   cell_editable = gtk_cell_area_get_edit_widget (area);
3053
3054                   if (cell_editable != NULL)
3055                     {
3056                       gtk_tree_path_free (path);
3057                       gtk_tree_path_free (anchor);
3058                       return TRUE;
3059                     }
3060                   column_handled_click = TRUE;
3061                 }
3062             }
3063           if (anchor)
3064             gtk_tree_path_free (anchor);
3065         }
3066
3067       extend_mod_mask =
3068         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
3069
3070       modify_mod_mask =
3071         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
3072
3073       /* select */
3074       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
3075       pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3076
3077       /* we only handle selection modifications on the first button press
3078        */
3079       if (event->type == GDK_BUTTON_PRESS)
3080         {
3081           GtkCellRenderer *focus_cell;
3082
3083           if ((event->state & modify_mod_mask) == modify_mod_mask)
3084             tree_view->priv->modify_selection_pressed = TRUE;
3085           if ((event->state & extend_mod_mask) == extend_mod_mask)
3086             tree_view->priv->extend_selection_pressed = TRUE;
3087
3088           /* We update the focus cell here, this is also needed if the
3089            * column does not contain an editable cell.  In this case,
3090            * GtkCellArea did not receive the event for processing (and
3091            * could not update the focus cell).
3092            */
3093           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column,
3094                                                               &cell_area,
3095                                                               &background_area,
3096                                                               event->x,
3097                                                               event->y);
3098
3099           if (focus_cell)
3100             gtk_tree_view_column_focus_cell (column, focus_cell);
3101
3102           if (event->state & modify_mod_mask)
3103             {
3104               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3105               gtk_tree_view_real_toggle_cursor_row (tree_view);
3106             }
3107           else if (event->state & extend_mod_mask)
3108             {
3109               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3110               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
3111             }
3112           else
3113             {
3114               gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
3115             }
3116
3117           tree_view->priv->modify_selection_pressed = FALSE;
3118           tree_view->priv->extend_selection_pressed = FALSE;
3119         }
3120
3121       /* the treeview may have been scrolled because of _set_cursor,
3122        * correct here
3123        */
3124
3125       aft_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3126       dval = pre_val - aft_val;
3127
3128       cell_area.y += dval;
3129       background_area.y += dval;
3130
3131       /* Save press to possibly begin a drag
3132        */
3133       if (!column_handled_click &&
3134           !tree_view->priv->in_grab &&
3135           tree_view->priv->pressed_button < 0)
3136         {
3137           tree_view->priv->pressed_button = event->button;
3138           tree_view->priv->press_start_x = event->x;
3139           tree_view->priv->press_start_y = event->y;
3140
3141           if (tree_view->priv->rubber_banding_enable
3142               && !node_selected
3143               && gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
3144             {
3145               tree_view->priv->press_start_y += tree_view->priv->dy;
3146               tree_view->priv->rubber_band_x = event->x;
3147               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
3148               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
3149
3150               if ((event->state & modify_mod_mask) == modify_mod_mask)
3151                 tree_view->priv->rubber_band_modify = TRUE;
3152               if ((event->state & extend_mod_mask) == extend_mod_mask)
3153                 tree_view->priv->rubber_band_extend = TRUE;
3154             }
3155         }
3156
3157       /* Test if a double click happened on the same row. */
3158       if (event->button == GDK_BUTTON_PRIMARY && event->type == GDK_BUTTON_PRESS)
3159         {
3160           int double_click_time, double_click_distance;
3161
3162           g_object_get (gtk_settings_get_default (),
3163                         "gtk-double-click-time", &double_click_time,
3164                         "gtk-double-click-distance", &double_click_distance,
3165                         NULL);
3166
3167           /* Same conditions as _gdk_event_button_generate */
3168           if (tree_view->priv->last_button_x != -1 &&
3169               (event->time < tree_view->priv->last_button_time + double_click_time) &&
3170               (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
3171               (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
3172             {
3173               /* We do no longer compare paths of this row and the
3174                * row clicked previously.  We use the double click
3175                * distance to decide whether this is a valid click,
3176                * allowing the mouse to slightly move over another row.
3177                */
3178               row_double_click = TRUE;
3179
3180               tree_view->priv->last_button_time = 0;
3181               tree_view->priv->last_button_x = -1;
3182               tree_view->priv->last_button_y = -1;
3183             }
3184           else
3185             {
3186               tree_view->priv->last_button_time = event->time;
3187               tree_view->priv->last_button_x = event->x;
3188               tree_view->priv->last_button_y = event->y;
3189             }
3190         }
3191
3192       if (row_double_click)
3193         {
3194           gtk_grab_remove (widget);
3195           gtk_tree_view_row_activated (tree_view, path, column);
3196
3197           if (tree_view->priv->pressed_button == event->button)
3198             tree_view->priv->pressed_button = -1;
3199         }
3200
3201       gtk_tree_path_free (path);
3202
3203       /* If we activated the row through a double click we don't want to grab
3204        * focus back, as moving focus to another widget is pretty common.
3205        */
3206       if (!row_double_click)
3207         grab_focus_and_unset_draw_keyfocus (tree_view);
3208
3209       return TRUE;
3210     }
3211
3212   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
3213    */
3214   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
3215     {
3216       column = list->data;
3217       if (event->window == _gtk_tree_view_column_get_window (column) &&
3218           gtk_tree_view_column_get_resizable (column) &&
3219           _gtk_tree_view_column_get_window (column))
3220         {
3221           gpointer drag_data;
3222
3223           if (event->type == GDK_2BUTTON_PRESS &&
3224               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
3225             {
3226               _gtk_tree_view_column_set_use_resized_width (column, FALSE);
3227               _gtk_tree_view_column_autosize (tree_view, column);
3228               return TRUE;
3229             }
3230
3231           if (gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
3232                                _gtk_tree_view_column_get_window (column),
3233                                GDK_OWNERSHIP_NONE,
3234                                FALSE,
3235                                GDK_POINTER_MOTION_HINT_MASK
3236                                 | GDK_BUTTON1_MOTION_MASK
3237                                 | GDK_BUTTON_RELEASE_MASK,
3238                                NULL,
3239                                event->time) != GDK_GRAB_SUCCESS)
3240             return FALSE;
3241
3242           gtk_grab_add (widget);
3243           tree_view->priv->in_column_resize = TRUE;
3244
3245           _gtk_tree_view_column_set_resized_width (column, gtk_tree_view_column_get_width (column) -
3246                                                    tree_view->priv->last_extra_space_per_column);
3247
3248           /* block attached dnd signal handler */
3249           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3250           if (drag_data)
3251             g_signal_handlers_block_matched (widget,
3252                                              G_SIGNAL_MATCH_DATA,
3253                                              0, 0, NULL, NULL,
3254                                              drag_data);
3255
3256           tree_view->priv->drag_pos = i;
3257           tree_view->priv->x_drag = gtk_tree_view_column_get_x_offset (column) + (rtl ? 0 : gtk_tree_view_column_get_width (column));
3258
3259           if (!gtk_widget_has_focus (widget))
3260             gtk_widget_grab_focus (widget);
3261
3262           return TRUE;
3263         }
3264     }
3265   return FALSE;
3266 }
3267
3268 /* GtkWidget::button_release_event helper */
3269 static gboolean
3270 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
3271                                           GdkEventButton *event)
3272 {
3273   GtkTreeView *tree_view;
3274   GtkWidget *button;
3275   GList *l;
3276   gboolean rtl;
3277   GdkDevice *device, *other;
3278
3279   tree_view = GTK_TREE_VIEW (widget);
3280
3281   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
3282   device = gdk_event_get_device ((GdkEvent*)event);
3283   other = gdk_device_get_associated_device (device);
3284   gdk_device_ungrab (device, event->time);
3285   gdk_device_ungrab (other, event->time);
3286
3287   /* Move the button back */
3288   button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3289   g_object_ref (button);
3290   gtk_container_remove (GTK_CONTAINER (tree_view), button);
3291   gtk_widget_set_parent_window (button, tree_view->priv->header_window);
3292   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
3293   g_object_unref (button);
3294   gtk_widget_queue_resize (widget);
3295   if (gtk_tree_view_column_get_resizable (tree_view->priv->drag_column))
3296     {
3297       gdk_window_raise (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3298       gdk_window_show (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3299     }
3300   else
3301     gdk_window_hide (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3302
3303   gtk_widget_grab_focus (button);
3304
3305   if (rtl)
3306     {
3307       if (tree_view->priv->cur_reorder &&
3308           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
3309         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3310                                          tree_view->priv->cur_reorder->right_column);
3311     }
3312   else
3313     {
3314       if (tree_view->priv->cur_reorder &&
3315           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
3316         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3317                                          tree_view->priv->cur_reorder->left_column);
3318     }
3319   tree_view->priv->drag_column = NULL;
3320   gdk_window_destroy (tree_view->priv->drag_window);
3321   tree_view->priv->drag_window = NULL;
3322
3323   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
3324     g_slice_free (GtkTreeViewColumnReorder, l->data);
3325   g_list_free (tree_view->priv->column_drag_info);
3326   tree_view->priv->column_drag_info = NULL;
3327   tree_view->priv->cur_reorder = NULL;
3328
3329   if (tree_view->priv->drag_highlight_window)
3330     gdk_window_hide (tree_view->priv->drag_highlight_window);
3331
3332   /* Reset our flags */
3333   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
3334   tree_view->priv->in_column_drag = FALSE;
3335
3336   return TRUE;
3337 }
3338
3339 /* GtkWidget::button_release_event helper */
3340 static gboolean
3341 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
3342                                             GdkEventButton *event)
3343 {
3344   GtkTreeView *tree_view;
3345   gpointer drag_data;
3346
3347   tree_view = GTK_TREE_VIEW (widget);
3348
3349   tree_view->priv->drag_pos = -1;
3350
3351   /* unblock attached dnd signal handler */
3352   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3353   if (drag_data)
3354     g_signal_handlers_unblock_matched (widget,
3355                                        G_SIGNAL_MATCH_DATA,
3356                                        0, 0, NULL, NULL,
3357                                        drag_data);
3358
3359   tree_view->priv->in_column_resize = FALSE;
3360   gtk_grab_remove (widget);
3361   gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
3362   return TRUE;
3363 }
3364
3365 static gboolean
3366 gtk_tree_view_button_release (GtkWidget      *widget,
3367                               GdkEventButton *event)
3368 {
3369   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3370
3371   if (tree_view->priv->in_column_drag)
3372     return gtk_tree_view_button_release_drag_column (widget, event);
3373
3374   if (tree_view->priv->rubber_band_status)
3375     gtk_tree_view_stop_rubber_band (tree_view);
3376
3377   if (tree_view->priv->pressed_button == event->button)
3378     tree_view->priv->pressed_button = -1;
3379
3380   if (tree_view->priv->in_column_resize)
3381     return gtk_tree_view_button_release_column_resize (widget, event);
3382
3383   if (tree_view->priv->button_pressed_node == NULL)
3384     return FALSE;
3385
3386   if (event->button == GDK_BUTTON_PRIMARY)
3387     {
3388       if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
3389           tree_view->priv->arrow_prelit)
3390         {
3391           GtkTreePath *path = NULL;
3392
3393           path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
3394                                                  tree_view->priv->button_pressed_node);
3395           /* Actually activate the node */
3396           if (tree_view->priv->button_pressed_node->children == NULL)
3397             gtk_tree_view_real_expand_row (tree_view, path,
3398                                            tree_view->priv->button_pressed_tree,
3399                                            tree_view->priv->button_pressed_node,
3400                                            FALSE, TRUE);
3401           else
3402             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3403                                              tree_view->priv->button_pressed_tree,
3404                                              tree_view->priv->button_pressed_node, TRUE);
3405           gtk_tree_path_free (path);
3406         }
3407
3408       gtk_grab_remove (widget);
3409       tree_view->priv->button_pressed_tree = NULL;
3410       tree_view->priv->button_pressed_node = NULL;
3411     }
3412
3413   return TRUE;
3414 }
3415
3416 static gboolean
3417 gtk_tree_view_grab_broken (GtkWidget          *widget,
3418                            GdkEventGrabBroken *event)
3419 {
3420   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3421
3422   if (tree_view->priv->in_column_drag)
3423     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3424
3425   if (tree_view->priv->in_column_resize)
3426     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3427
3428   return TRUE;
3429 }
3430
3431 #if 0
3432 static gboolean
3433 gtk_tree_view_configure (GtkWidget *widget,
3434                          GdkEventConfigure *event)
3435 {
3436   GtkTreeView *tree_view;
3437
3438   tree_view = GTK_TREE_VIEW (widget);
3439   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3440
3441   return FALSE;
3442 }
3443 #endif
3444
3445 /* GtkWidget::motion_event function set.
3446  */
3447
3448 static gboolean
3449 coords_are_over_arrow (GtkTreeView *tree_view,
3450                        GtkRBTree   *tree,
3451                        GtkRBNode   *node,
3452                        /* these are in bin window coords */
3453                        gint         x,
3454                        gint         y)
3455 {
3456   GdkRectangle arrow;
3457   gint x2;
3458
3459   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
3460     return FALSE;
3461
3462   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3463     return FALSE;
3464
3465   arrow.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
3466   arrow.height = gtk_tree_view_get_row_height (tree_view, node);
3467
3468   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3469
3470   arrow.width = x2 - arrow.x;
3471
3472   return (x >= arrow.x &&
3473           x < (arrow.x + arrow.width) &&
3474           y >= arrow.y &&
3475           y < (arrow.y + arrow.height));
3476 }
3477
3478 static gboolean
3479 auto_expand_timeout (gpointer data)
3480 {
3481   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3482   GtkTreePath *path;
3483
3484   if (tree_view->priv->prelight_node)
3485     {
3486       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->prelight_tree,
3487                                              tree_view->priv->prelight_node);
3488
3489       if (tree_view->priv->prelight_node->children)
3490         gtk_tree_view_collapse_row (tree_view, path);
3491       else
3492         gtk_tree_view_expand_row (tree_view, path, FALSE);
3493
3494       gtk_tree_path_free (path);
3495     }
3496
3497   tree_view->priv->auto_expand_timeout = 0;
3498
3499   return FALSE;
3500 }
3501
3502 static void
3503 remove_auto_expand_timeout (GtkTreeView *tree_view)
3504 {
3505   if (tree_view->priv->auto_expand_timeout != 0)
3506     {
3507       g_source_remove (tree_view->priv->auto_expand_timeout);
3508       tree_view->priv->auto_expand_timeout = 0;
3509     }
3510 }
3511
3512 static void
3513 do_prelight (GtkTreeView *tree_view,
3514              GtkRBTree   *tree,
3515              GtkRBNode   *node,
3516              /* these are in bin_window coords */
3517              gint         x,
3518              gint         y)
3519 {
3520   if (tree_view->priv->prelight_tree == tree &&
3521       tree_view->priv->prelight_node == node)
3522     {
3523       /*  We are still on the same node,
3524           but we might need to take care of the arrow  */
3525
3526       if (tree && node && gtk_tree_view_draw_expanders (tree_view))
3527         {
3528           gboolean over_arrow;
3529
3530           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3531
3532           if (over_arrow != tree_view->priv->arrow_prelit)
3533             {
3534               if (over_arrow)
3535                 tree_view->priv->arrow_prelit = TRUE;
3536               else
3537                 tree_view->priv->arrow_prelit = FALSE;
3538
3539               gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3540             }
3541         }
3542
3543       return;
3544     }
3545
3546   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3547     {
3548       /*  Unprelight the old node and arrow  */
3549
3550       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3551                              GTK_RBNODE_IS_PRELIT);
3552
3553       if (tree_view->priv->arrow_prelit
3554           && gtk_tree_view_draw_expanders (tree_view))
3555         {
3556           tree_view->priv->arrow_prelit = FALSE;
3557
3558           gtk_tree_view_queue_draw_arrow (tree_view,
3559                                           tree_view->priv->prelight_tree,
3560                                           tree_view->priv->prelight_node);
3561         }
3562
3563       _gtk_tree_view_queue_draw_node (tree_view,
3564                                       tree_view->priv->prelight_tree,
3565                                       tree_view->priv->prelight_node,
3566                                       NULL);
3567     }
3568
3569
3570   if (tree_view->priv->hover_expand)
3571     remove_auto_expand_timeout (tree_view);
3572
3573   /*  Set the new prelight values  */
3574   tree_view->priv->prelight_node = node;
3575   tree_view->priv->prelight_tree = tree;
3576
3577   if (!node || !tree)
3578     return;
3579
3580   /*  Prelight the new node and arrow  */
3581
3582   if (gtk_tree_view_draw_expanders (tree_view)
3583       && coords_are_over_arrow (tree_view, tree, node, x, y))
3584     {
3585       tree_view->priv->arrow_prelit = TRUE;
3586
3587       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3588     }
3589
3590   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3591
3592   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3593
3594   if (tree_view->priv->hover_expand)
3595     {
3596       tree_view->priv->auto_expand_timeout =
3597         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3598     }
3599 }
3600
3601 static void
3602 prelight_or_select (GtkTreeView *tree_view,
3603                     GtkRBTree   *tree,
3604                     GtkRBNode   *node,
3605                     /* these are in bin_window coords */
3606                     gint         x,
3607                     gint         y)
3608 {
3609   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3610
3611   if (tree_view->priv->hover_selection &&
3612       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3613       !(tree_view->priv->edited_column &&
3614         gtk_cell_area_get_edit_widget
3615         (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column)))))
3616     {
3617       if (node)
3618         {
3619           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3620             {
3621               GtkTreePath *path;
3622
3623               path = _gtk_tree_path_new_from_rbtree (tree, node);
3624               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3625               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3626                 {
3627                   tree_view->priv->draw_keyfocus = FALSE;
3628                   gtk_tree_view_real_set_cursor (tree_view, path, 0);
3629                 }
3630               gtk_tree_path_free (path);
3631             }
3632         }
3633
3634       else if (mode == GTK_SELECTION_SINGLE)
3635         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3636     }
3637
3638     do_prelight (tree_view, tree, node, x, y);
3639 }
3640
3641 static void
3642 ensure_unprelighted (GtkTreeView *tree_view)
3643 {
3644   do_prelight (tree_view,
3645                NULL, NULL,
3646                -1000, -1000); /* coords not possibly over an arrow */
3647
3648   g_assert (tree_view->priv->prelight_node == NULL);
3649 }
3650
3651 static void
3652 update_prelight (GtkTreeView *tree_view,
3653                  gint         x,
3654                  gint         y)
3655 {
3656   int new_y;
3657   GtkRBTree *tree;
3658   GtkRBNode *node;
3659
3660   if (tree_view->priv->tree == NULL)
3661     return;
3662
3663   if (x == -10000)
3664     {
3665       ensure_unprelighted (tree_view);
3666       return;
3667     }
3668
3669   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
3670   if (new_y < 0)
3671     new_y = 0;
3672
3673   _gtk_rbtree_find_offset (tree_view->priv->tree,
3674                            new_y, &tree, &node);
3675
3676   if (node)
3677     prelight_or_select (tree_view, tree, node, x, y);
3678 }
3679
3680
3681
3682
3683 /* Our motion arrow is either a box (in the case of the original spot)
3684  * or an arrow.  It is expander_size wide.
3685  */
3686 /*
3687  * 11111111111111
3688  * 01111111111110
3689  * 00111111111100
3690  * 00011111111000
3691  * 00001111110000
3692  * 00000111100000
3693  * 00000111100000
3694  * 00000111100000
3695  * ~ ~ ~ ~ ~ ~ ~
3696  * 00000111100000
3697  * 00000111100000
3698  * 00000111100000
3699  * 00001111110000
3700  * 00011111111000
3701  * 00111111111100
3702  * 01111111111110
3703  * 11111111111111
3704  */
3705
3706 static void
3707 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3708 {
3709   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3710   GtkWidget *widget = GTK_WIDGET (tree_view);
3711   cairo_surface_t *mask_image;
3712   cairo_region_t *mask_region;
3713   gint x;
3714   gint y;
3715   gint width;
3716   gint height;
3717   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3718   GdkWindowAttr attributes;
3719   guint attributes_mask;
3720   cairo_t *cr;
3721
3722   if (!reorder ||
3723       reorder->left_column == tree_view->priv->drag_column ||
3724       reorder->right_column == tree_view->priv->drag_column)
3725     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3726   else if (reorder->left_column || reorder->right_column)
3727     {
3728       GtkAllocation left_allocation, right_allocation;
3729       GdkRectangle visible_rect;
3730       GtkWidget *button;
3731
3732       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3733       if (reorder->left_column)
3734         {
3735           button = gtk_tree_view_column_get_button (reorder->left_column);
3736           gtk_widget_get_allocation (button, &left_allocation);
3737           x = left_allocation.x + left_allocation.width;
3738         }
3739       else
3740         {
3741           button = gtk_tree_view_column_get_button (reorder->right_column);
3742           gtk_widget_get_allocation (button, &right_allocation);
3743           x = right_allocation.x;
3744         }
3745
3746       if (x < visible_rect.x)
3747         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3748       else if (x > visible_rect.x + visible_rect.width)
3749         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3750       else
3751         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3752     }
3753
3754   /* We want to draw the rectangle over the initial location. */
3755   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3756     {
3757       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3758         {
3759           GtkAllocation drag_allocation;
3760           GtkWidget    *button;
3761
3762           if (tree_view->priv->drag_highlight_window)
3763             {
3764               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3765                                         NULL);
3766               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3767             }
3768
3769           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3770           attributes.window_type = GDK_WINDOW_CHILD;
3771           attributes.wclass = GDK_INPUT_OUTPUT;
3772           attributes.x = tree_view->priv->drag_column_x;
3773           attributes.y = 0;
3774           gtk_widget_get_allocation (button, &drag_allocation);
3775           width = attributes.width = drag_allocation.width;
3776           height = attributes.height = drag_allocation.height;
3777           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3778           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3779           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3780           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3781           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3782
3783           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3784           cr = cairo_create (mask_image);
3785
3786           cairo_rectangle (cr, 1, 1, width - 2, height - 2);
3787           cairo_stroke (cr);
3788           cairo_destroy (cr);
3789
3790           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3791           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3792                                            mask_region, 0, 0);
3793
3794           cairo_region_destroy (mask_region);
3795           cairo_surface_destroy (mask_image);
3796
3797           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3798         }
3799     }
3800   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3801     {
3802       GtkAllocation button_allocation;
3803       GtkWidget    *button;
3804
3805       width = gtk_tree_view_get_expander_size (tree_view);
3806
3807       /* Get x, y, width, height of arrow */
3808       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3809       if (reorder->left_column)
3810         {
3811           button = gtk_tree_view_column_get_button (reorder->left_column);
3812           gtk_widget_get_allocation (button, &button_allocation);
3813           x += button_allocation.x + button_allocation.width - width/2;
3814           height = button_allocation.height;
3815         }
3816       else
3817         {
3818           button = gtk_tree_view_column_get_button (reorder->right_column);
3819           gtk_widget_get_allocation (button, &button_allocation);
3820           x += button_allocation.x - width/2;
3821           height = button_allocation.height;
3822         }
3823       y -= width/2; /* The arrow takes up only half the space */
3824       height += width;
3825
3826       /* Create the new window */
3827       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3828         {
3829           if (tree_view->priv->drag_highlight_window)
3830             {
3831               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3832                                         NULL);
3833               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3834             }
3835
3836           attributes.window_type = GDK_WINDOW_TEMP;
3837           attributes.wclass = GDK_INPUT_OUTPUT;
3838           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3839           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3840           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3841           attributes.x = x;
3842           attributes.y = y;
3843           attributes.width = width;
3844           attributes.height = height;
3845           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3846                                                                    &attributes, attributes_mask);
3847           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3848
3849           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3850
3851           cr = cairo_create (mask_image);
3852           cairo_move_to (cr, 0, 0);
3853           cairo_line_to (cr, width, 0);
3854           cairo_line_to (cr, width / 2., width / 2);
3855           cairo_move_to (cr, 0, height);
3856           cairo_line_to (cr, width, height);
3857           cairo_line_to (cr, width / 2., height - width / 2.);
3858           cairo_fill (cr);
3859           cairo_destroy (cr);
3860
3861           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3862           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3863                                            mask_region, 0, 0);
3864
3865           cairo_region_destroy (mask_region);
3866           cairo_surface_destroy (mask_image);
3867         }
3868
3869       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3870       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3871     }
3872   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3873            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3874     {
3875       GtkAllocation allocation;
3876       GtkWidget    *button;
3877       gint          expander_size;
3878
3879       expander_size = gtk_tree_view_get_expander_size (tree_view);
3880
3881       /* Get x, y, width, height of arrow */
3882       width = expander_size/2; /* remember, the arrow only takes half the available width */
3883       gdk_window_get_origin (gtk_widget_get_window (widget),
3884                              &x, &y);
3885       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3886         {
3887           gtk_widget_get_allocation (widget, &allocation);
3888           x += allocation.width - width;
3889         }
3890
3891       if (reorder->left_column)
3892         {
3893           button = gtk_tree_view_column_get_button (reorder->left_column);
3894           gtk_widget_get_allocation (button, &allocation);
3895           height = allocation.height;
3896         }
3897       else
3898         {
3899           button = gtk_tree_view_column_get_button (reorder->right_column);
3900           gtk_widget_get_allocation (button, &allocation);
3901           height = allocation.height;
3902         }
3903
3904       y -= expander_size;
3905       height += 2 * expander_size;
3906
3907       /* Create the new window */
3908       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3909           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3910         {
3911           if (tree_view->priv->drag_highlight_window)
3912             {
3913               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3914                                         NULL);
3915               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3916             }
3917
3918           attributes.window_type = GDK_WINDOW_TEMP;
3919           attributes.wclass = GDK_INPUT_OUTPUT;
3920           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3921           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3922           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3923           attributes.x = x;
3924           attributes.y = y;
3925           attributes.width = width;
3926           attributes.height = height;
3927           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget), &attributes, attributes_mask);
3928           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3929
3930           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3931
3932           cr = cairo_create (mask_image);
3933           /* mirror if we're on the left */
3934           if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3935             {
3936               cairo_translate (cr, width, 0);
3937               cairo_scale (cr, -1, 1);
3938             }
3939           cairo_move_to (cr, 0, 0);
3940           cairo_line_to (cr, width, width);
3941           cairo_line_to (cr, 0, expander_size);
3942           cairo_move_to (cr, 0, height);
3943           cairo_line_to (cr, width, height - width);
3944           cairo_line_to (cr, 0, height - expander_size);
3945           cairo_fill (cr);
3946           cairo_destroy (cr);
3947
3948           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3949           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3950                                            mask_region, 0, 0);
3951
3952           cairo_region_destroy (mask_region);
3953           cairo_surface_destroy (mask_image);
3954         }
3955
3956       tree_view->priv->drag_column_window_state = arrow_type;
3957       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3958    }
3959   else
3960     {
3961       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
3962       gdk_window_hide (tree_view->priv->drag_highlight_window);
3963       return;
3964     }
3965
3966   gdk_window_show (tree_view->priv->drag_highlight_window);
3967   gdk_window_raise (tree_view->priv->drag_highlight_window);
3968 }
3969
3970 static gboolean
3971 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
3972                                     GdkEventMotion *event)
3973 {
3974   gint x;
3975   gint new_width;
3976   GtkTreeViewColumn *column;
3977   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3978
3979   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
3980
3981   if (event->is_hint || event->window != gtk_widget_get_window (widget))
3982     gdk_window_get_device_position (gtk_widget_get_window (widget),
3983                                     gdk_event_get_device ((GdkEvent *) event),
3984                                     &x, NULL, NULL);
3985   else
3986     x = event->x;
3987
3988   if (tree_view->priv->hadjustment)
3989     x += gtk_adjustment_get_value (tree_view->priv->hadjustment);
3990
3991   new_width = gtk_tree_view_new_column_width (tree_view,
3992                                               tree_view->priv->drag_pos, &x);
3993   if (x != tree_view->priv->x_drag &&
3994       (new_width != gtk_tree_view_column_get_fixed_width (column)))
3995     {
3996       _gtk_tree_view_column_set_use_resized_width (column, TRUE);
3997
3998       if (gtk_tree_view_column_get_expand (column))
3999         new_width -= tree_view->priv->last_extra_space_per_column;
4000
4001       _gtk_tree_view_column_set_resized_width (column, new_width);
4002
4003
4004       gtk_widget_queue_resize (widget);
4005     }
4006
4007   return FALSE;
4008 }
4009
4010
4011 static void
4012 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view,
4013                                       GdkEvent    *event)
4014 {
4015   GtkTreeViewColumnReorder *reorder = NULL;
4016   GList *list;
4017   gint mouse_x;
4018
4019   gdk_window_get_device_position (tree_view->priv->header_window,
4020                                   gdk_event_get_device (event),
4021                                   &mouse_x, NULL, NULL);
4022   for (list = tree_view->priv->column_drag_info; list; list = list->next)
4023     {
4024       reorder = (GtkTreeViewColumnReorder *) list->data;
4025       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
4026         break;
4027       reorder = NULL;
4028     }
4029
4030   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
4031       return;*/
4032
4033   tree_view->priv->cur_reorder = reorder;
4034   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
4035 }
4036
4037 static void
4038 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
4039 {
4040   GdkRectangle visible_rect;
4041   gint y;
4042   gint offset;
4043
4044   gdk_window_get_device_position (tree_view->priv->bin_window,
4045                                   gdk_device_manager_get_client_pointer (
4046                                     gdk_display_get_device_manager (
4047                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4048                                   NULL, &y, NULL);
4049   y += tree_view->priv->dy;
4050
4051   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4052
4053   /* see if we are near the edge. */
4054   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
4055   if (offset > 0)
4056     {
4057       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
4058       if (offset < 0)
4059         return;
4060     }
4061
4062   gtk_adjustment_set_value (tree_view->priv->vadjustment,
4063                             MAX (gtk_adjustment_get_value (tree_view->priv->vadjustment) + offset, 0.0));
4064 }
4065
4066 static gboolean
4067 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view,
4068                                      GdkEvent    *event)
4069 {
4070   GdkRectangle visible_rect;
4071   gint x;
4072   gint offset;
4073
4074   gdk_window_get_device_position (tree_view->priv->bin_window,
4075                                   gdk_event_get_device (event),
4076                                   &x, NULL, NULL);
4077
4078   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4079
4080   /* See if we are near the edge. */
4081   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
4082   if (offset > 0)
4083     {
4084       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
4085       if (offset < 0)
4086         return TRUE;
4087     }
4088   offset = offset/3;
4089
4090   gtk_adjustment_set_value (tree_view->priv->hadjustment,
4091                             MAX (gtk_adjustment_get_value (tree_view->priv->hadjustment) + offset, 0.0));
4092
4093   return TRUE;
4094
4095 }
4096
4097 static gboolean
4098 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
4099                                   GdkEventMotion *event)
4100 {
4101   GtkAllocation allocation, button_allocation;
4102   GtkTreeView *tree_view = (GtkTreeView *) widget;
4103   GtkTreeViewColumn *column = tree_view->priv->drag_column;
4104   GtkWidget *button;
4105   gint x, y;
4106
4107   /* Sanity Check */
4108   if ((column == NULL) ||
4109       (event->window != tree_view->priv->drag_window))
4110     return FALSE;
4111
4112   button = gtk_tree_view_column_get_button (column);
4113
4114   /* Handle moving the header */
4115   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
4116   gtk_widget_get_allocation (widget, &allocation);
4117   gtk_widget_get_allocation (button, &button_allocation);
4118   x = CLAMP (x + (gint)event->x - _gtk_tree_view_column_get_drag_x (column), 0,
4119              MAX (tree_view->priv->width, allocation.width) - button_allocation.width);
4120   gdk_window_move (tree_view->priv->drag_window, x, y);
4121
4122   /* autoscroll, if needed */
4123   gtk_tree_view_horizontal_autoscroll (tree_view, (GdkEvent *) event);
4124   /* Update the current reorder position and arrow; */
4125   gtk_tree_view_update_current_reorder (tree_view, (GdkEvent *) event);
4126
4127   return TRUE;
4128 }
4129
4130 static void
4131 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
4132 {
4133   remove_scroll_timeout (tree_view);
4134   gtk_grab_remove (GTK_WIDGET (tree_view));
4135
4136   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4137     {
4138       GtkTreePath *tmp_path;
4139
4140       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4141
4142       /* The anchor path should be set to the start path */
4143       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_start_tree,
4144                                                  tree_view->priv->rubber_band_start_node);
4145
4146       if (tree_view->priv->anchor)
4147         gtk_tree_row_reference_free (tree_view->priv->anchor);
4148
4149       tree_view->priv->anchor =
4150         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
4151                                           tree_view->priv->model,
4152                                           tmp_path);
4153
4154       gtk_tree_path_free (tmp_path);
4155
4156       /* ... and the cursor to the end path */
4157       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_end_tree,
4158                                                  tree_view->priv->rubber_band_end_node);
4159       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, 0);
4160       gtk_tree_path_free (tmp_path);
4161
4162       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
4163     }
4164
4165   /* Clear status variables */
4166   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
4167   tree_view->priv->rubber_band_extend = FALSE;
4168   tree_view->priv->rubber_band_modify = FALSE;
4169
4170   tree_view->priv->rubber_band_start_node = NULL;
4171   tree_view->priv->rubber_band_start_tree = NULL;
4172   tree_view->priv->rubber_band_end_node = NULL;
4173   tree_view->priv->rubber_band_end_tree = NULL;
4174 }
4175
4176 static void
4177 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
4178                                                  GtkRBTree   *start_tree,
4179                                                  GtkRBNode   *start_node,
4180                                                  GtkRBTree   *end_tree,
4181                                                  GtkRBNode   *end_node,
4182                                                  gboolean     select,
4183                                                  gboolean     skip_start,
4184                                                  gboolean     skip_end)
4185 {
4186   if (start_node == end_node)
4187     return;
4188
4189   /* We skip the first node and jump inside the loop */
4190   if (skip_start)
4191     goto skip_first;
4192
4193   do
4194     {
4195       /* Small optimization by assuming insensitive nodes are never
4196        * selected.
4197        */
4198       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4199         {
4200           GtkTreePath *path;
4201           gboolean selectable;
4202
4203           path = _gtk_tree_path_new_from_rbtree (start_tree, start_node);
4204           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
4205           gtk_tree_path_free (path);
4206
4207           if (!selectable)
4208             goto node_not_selectable;
4209         }
4210
4211       if (select)
4212         {
4213           if (tree_view->priv->rubber_band_extend)
4214             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4215           else if (tree_view->priv->rubber_band_modify)
4216             {
4217               /* Toggle the selection state */
4218               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4219                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4220               else
4221                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4222             }
4223           else
4224             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4225         }
4226       else
4227         {
4228           /* Mirror the above */
4229           if (tree_view->priv->rubber_band_extend)
4230             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4231           else if (tree_view->priv->rubber_band_modify)
4232             {
4233               /* Toggle the selection state */
4234               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4235                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4236               else
4237                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4238             }
4239           else
4240             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4241         }
4242
4243       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
4244
4245 node_not_selectable:
4246       if (start_node == end_node)
4247         break;
4248
4249 skip_first:
4250
4251       if (start_node->children)
4252         {
4253           start_tree = start_node->children;
4254           start_node = _gtk_rbtree_first (start_tree);
4255         }
4256       else
4257         {
4258           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
4259
4260           if (!start_tree)
4261             /* Ran out of tree */
4262             break;
4263         }
4264
4265       if (skip_end && start_node == end_node)
4266         break;
4267     }
4268   while (TRUE);
4269 }
4270
4271 static void
4272 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
4273 {
4274   GtkRBTree *start_tree, *end_tree;
4275   GtkRBNode *start_node, *end_node;
4276
4277   _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);
4278   _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);
4279
4280   /* Handle the start area first */
4281   if (!tree_view->priv->rubber_band_start_node)
4282     {
4283       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4284                                                        start_tree,
4285                                                        start_node,
4286                                                        end_tree,
4287                                                        end_node,
4288                                                        TRUE,
4289                                                        FALSE,
4290                                                        FALSE);
4291     }
4292   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
4293            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4294     {
4295       /* New node is above the old one; selection became bigger */
4296       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4297                                                        start_tree,
4298                                                        start_node,
4299                                                        tree_view->priv->rubber_band_start_tree,
4300                                                        tree_view->priv->rubber_band_start_node,
4301                                                        TRUE,
4302                                                        FALSE,
4303                                                        TRUE);
4304     }
4305   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
4306            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4307     {
4308       /* New node is below the old one; selection became smaller */
4309       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4310                                                        tree_view->priv->rubber_band_start_tree,
4311                                                        tree_view->priv->rubber_band_start_node,
4312                                                        start_tree,
4313                                                        start_node,
4314                                                        FALSE,
4315                                                        FALSE,
4316                                                        TRUE);
4317     }
4318
4319   tree_view->priv->rubber_band_start_tree = start_tree;
4320   tree_view->priv->rubber_band_start_node = start_node;
4321
4322   /* Next, handle the end area */
4323   if (!tree_view->priv->rubber_band_end_node)
4324     {
4325       /* In the event this happens, start_node was also NULL; this case is
4326        * handled above.
4327        */
4328     }
4329   else if (!end_node)
4330     {
4331       /* Find the last node in the tree */
4332       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
4333                                &end_tree, &end_node);
4334
4335       /* Selection reached end of the tree */
4336       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4337                                                        tree_view->priv->rubber_band_end_tree,
4338                                                        tree_view->priv->rubber_band_end_node,
4339                                                        end_tree,
4340                                                        end_node,
4341                                                        TRUE,
4342                                                        TRUE,
4343                                                        FALSE);
4344     }
4345   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
4346            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4347     {
4348       /* New node is below the old one; selection became bigger */
4349       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4350                                                        tree_view->priv->rubber_band_end_tree,
4351                                                        tree_view->priv->rubber_band_end_node,
4352                                                        end_tree,
4353                                                        end_node,
4354                                                        TRUE,
4355                                                        TRUE,
4356                                                        FALSE);
4357     }
4358   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
4359            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4360     {
4361       /* New node is above the old one; selection became smaller */
4362       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4363                                                        end_tree,
4364                                                        end_node,
4365                                                        tree_view->priv->rubber_band_end_tree,
4366                                                        tree_view->priv->rubber_band_end_node,
4367                                                        FALSE,
4368                                                        TRUE,
4369                                                        FALSE);
4370     }
4371
4372   tree_view->priv->rubber_band_end_tree = end_tree;
4373   tree_view->priv->rubber_band_end_node = end_node;
4374 }
4375
4376 static void
4377 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
4378 {
4379   gint x, y;
4380   GdkRectangle old_area;
4381   GdkRectangle new_area;
4382   GdkRectangle common;
4383   cairo_region_t *invalid_region;
4384
4385   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4386   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4387   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
4388   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
4389
4390   gdk_window_get_device_position (tree_view->priv->bin_window,
4391                                   gdk_device_manager_get_client_pointer (
4392                                     gdk_display_get_device_manager (
4393                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4394                                   &x, &y, NULL);
4395
4396   x = MAX (x, 0);
4397   y = MAX (y, 0) + tree_view->priv->dy;
4398
4399   new_area.x = MIN (tree_view->priv->press_start_x, x);
4400   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
4401   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
4402   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
4403
4404   invalid_region = cairo_region_create_rectangle (&old_area);
4405   cairo_region_union_rectangle (invalid_region, &new_area);
4406
4407   gdk_rectangle_intersect (&old_area, &new_area, &common);
4408   if (common.width > 2 && common.height > 2)
4409     {
4410       cairo_region_t *common_region;
4411
4412       /* make sure the border is invalidated */
4413       common.x += 1;
4414       common.y += 1;
4415       common.width -= 2;
4416       common.height -= 2;
4417
4418       common_region = cairo_region_create_rectangle (&common);
4419
4420       cairo_region_subtract (invalid_region, common_region);
4421       cairo_region_destroy (common_region);
4422     }
4423
4424   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
4425
4426   cairo_region_destroy (invalid_region);
4427
4428   tree_view->priv->rubber_band_x = x;
4429   tree_view->priv->rubber_band_y = y;
4430
4431   gtk_tree_view_update_rubber_band_selection (tree_view);
4432 }
4433
4434 static void
4435 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4436                                  cairo_t      *cr)
4437 {
4438   GdkRectangle rect;
4439   GtkStyleContext *context;
4440
4441   cairo_save (cr);
4442
4443   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4444
4445   gtk_style_context_save (context);
4446   gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND);
4447
4448   rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4449   rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4450   rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4451   rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4452
4453   gdk_cairo_rectangle (cr, &rect);
4454   cairo_clip (cr);
4455
4456   gtk_render_background (context, cr,
4457                          rect.x, rect.y,
4458                          rect.width, rect.height);
4459   gtk_render_frame (context, cr,
4460                     rect.x, rect.y,
4461                     rect.width, rect.height);
4462
4463   gtk_style_context_restore (context);
4464   cairo_restore (cr);
4465 }
4466
4467 static gboolean
4468 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4469                                  GdkEventMotion *event)
4470 {
4471   GtkTreeView *tree_view;
4472   GtkRBTree *tree;
4473   GtkRBNode *node;
4474   gint new_y;
4475
4476   tree_view = (GtkTreeView *) widget;
4477
4478   if (tree_view->priv->tree == NULL)
4479     return FALSE;
4480
4481   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4482     {
4483       gtk_grab_add (GTK_WIDGET (tree_view));
4484       gtk_tree_view_update_rubber_band (tree_view);
4485
4486       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4487     }
4488   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4489     {
4490       gtk_tree_view_update_rubber_band (tree_view);
4491
4492       add_scroll_timeout (tree_view);
4493     }
4494
4495   /* only check for an initiated drag when a button is pressed */
4496   if (tree_view->priv->pressed_button >= 0
4497       && !tree_view->priv->rubber_band_status)
4498     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4499
4500   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4501   if (new_y < 0)
4502     new_y = 0;
4503
4504   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4505
4506   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4507   if ((tree_view->priv->button_pressed_node != NULL) &&
4508       (tree_view->priv->button_pressed_node != node))
4509     node = NULL;
4510
4511   tree_view->priv->event_last_x = event->x;
4512   tree_view->priv->event_last_y = event->y;
4513
4514   prelight_or_select (tree_view, tree, node, event->x, event->y);
4515
4516   return TRUE;
4517 }
4518
4519 static gboolean
4520 gtk_tree_view_motion (GtkWidget      *widget,
4521                       GdkEventMotion *event)
4522 {
4523   GtkTreeView *tree_view;
4524
4525   tree_view = (GtkTreeView *) widget;
4526
4527   /* Resizing a column */
4528   if (tree_view->priv->in_column_resize)
4529     return gtk_tree_view_motion_resize_column (widget, event);
4530
4531   /* Drag column */
4532   if (tree_view->priv->in_column_drag)
4533     return gtk_tree_view_motion_drag_column (widget, event);
4534
4535   /* Sanity check it */
4536   if (event->window == tree_view->priv->bin_window)
4537     return gtk_tree_view_motion_bin_window (widget, event);
4538
4539   return FALSE;
4540 }
4541
4542 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4543  * the tree is empty.
4544  */
4545 static void
4546 invalidate_empty_focus (GtkTreeView *tree_view)
4547 {
4548   GdkRectangle area;
4549
4550   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
4551     return;
4552
4553   area.x = 0;
4554   area.y = 0;
4555   area.width = gdk_window_get_width (tree_view->priv->bin_window);
4556   area.height = gdk_window_get_height (tree_view->priv->bin_window);
4557   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4558 }
4559
4560 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4561  * is empty.
4562  */
4563 static void
4564 draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr)
4565 {
4566   GtkWidget *widget = GTK_WIDGET (tree_view);
4567   gint w, h;
4568
4569   if (!gtk_widget_has_visible_focus (widget))
4570     return;
4571
4572   w = gdk_window_get_width (tree_view->priv->bin_window) - 2;
4573   h = gdk_window_get_height (tree_view->priv->bin_window) - 2;
4574
4575   if (w > 0 && h > 0)
4576     {
4577       GtkStyleContext *context;
4578
4579       context = gtk_widget_get_style_context (widget);
4580
4581       gtk_render_focus (context, cr, 1, 1, w, h);
4582     }
4583 }
4584
4585 typedef enum {
4586   GTK_TREE_VIEW_GRID_LINE,
4587   GTK_TREE_VIEW_TREE_LINE,
4588   GTK_TREE_VIEW_FOREGROUND_LINE
4589 } GtkTreeViewLineType;
4590
4591 static void
4592 gtk_tree_view_draw_line (GtkTreeView         *tree_view,
4593                          cairo_t             *cr,
4594                          GtkTreeViewLineType  type,
4595                          int                  x1,
4596                          int                  y1,
4597                          int                  x2,
4598                          int                  y2)
4599 {
4600   cairo_save (cr);
4601
4602   switch (type)
4603     {
4604     case GTK_TREE_VIEW_TREE_LINE:
4605       cairo_set_source_rgb (cr, 0, 0, 0);
4606       cairo_set_line_width (cr, tree_view->priv->tree_line_width);
4607       if (tree_view->priv->tree_line_dashes[0])
4608         cairo_set_dash (cr,
4609                         tree_view->priv->tree_line_dashes,
4610                         2, 0.5);
4611       break;
4612     case GTK_TREE_VIEW_GRID_LINE:
4613       cairo_set_source_rgb (cr, 0, 0, 0);
4614       cairo_set_line_width (cr, tree_view->priv->grid_line_width);
4615       if (tree_view->priv->grid_line_dashes[0])
4616         cairo_set_dash (cr,
4617                         tree_view->priv->grid_line_dashes,
4618                         2, 0.5);
4619       break;
4620     default:
4621       g_assert_not_reached ();
4622       /* fall through */
4623     case GTK_TREE_VIEW_FOREGROUND_LINE:
4624       {
4625         GtkStyleContext *context;
4626         GtkStateFlags state;
4627         GdkRGBA color;
4628
4629         context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4630         state = gtk_widget_get_state_flags (GTK_WIDGET (tree_view));
4631
4632         cairo_set_line_width (cr, 1.0);
4633         gtk_style_context_get_color (context, state, &color);
4634         gdk_cairo_set_source_rgba (cr, &color);
4635       }
4636
4637       break;
4638     }
4639
4640   cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
4641   cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
4642   cairo_stroke (cr);
4643
4644   cairo_restore (cr);
4645 }
4646
4647 static void
4648 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4649                                cairo_t        *cr,
4650                                gint            n_visible_columns)
4651 {
4652   GList *list = tree_view->priv->columns;
4653   gint i = 0;
4654   gint current_x = 0;
4655
4656   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4657       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4658     return;
4659
4660   /* Only draw the lines for visible rows and columns */
4661   for (list = tree_view->priv->columns; list; list = list->next, i++)
4662     {
4663       GtkTreeViewColumn *column = list->data;
4664
4665       /* We don't want a line for the last column */
4666       if (i == n_visible_columns - 1)
4667         break;
4668
4669       if (!gtk_tree_view_column_get_visible (column))
4670         continue;
4671
4672       current_x += gtk_tree_view_column_get_width (column);
4673
4674       gtk_tree_view_draw_line (tree_view, cr,
4675                                GTK_TREE_VIEW_GRID_LINE,
4676                                current_x - 1, 0,
4677                                current_x - 1, tree_view->priv->height);
4678     }
4679 }
4680
4681 /* Warning: Very scary function.
4682  * Modify at your own risk
4683  *
4684  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4685  * FIXME: It's not...
4686  */
4687 static gboolean
4688 gtk_tree_view_bin_draw (GtkWidget      *widget,
4689                         cairo_t        *cr)
4690 {
4691   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4692   GtkTreePath *path;
4693   GtkRBTree *tree;
4694   GList *list;
4695   GtkRBNode *node;
4696   GtkRBNode *drag_highlight = NULL;
4697   GtkRBTree *drag_highlight_tree = NULL;
4698   GtkTreeIter iter;
4699   gint new_y;
4700   gint y_offset, cell_offset;
4701   gint max_height;
4702   gint depth;
4703   GdkRectangle background_area;
4704   GdkRectangle cell_area;
4705   GdkRectangle clip;
4706   guint flags;
4707   gint highlight_x;
4708   gint expander_cell_width;
4709   gint bin_window_width;
4710   gint bin_window_height;
4711   GtkTreePath *drag_dest_path;
4712   GList *first_column, *last_column;
4713   gint vertical_separator;
4714   gint horizontal_separator;
4715   gboolean allow_rules;
4716   gboolean has_can_focus_cell;
4717   gboolean rtl;
4718   gint n_visible_columns;
4719   gint grid_line_width;
4720   gint expander_size;
4721   gboolean draw_vgrid_lines, draw_hgrid_lines;
4722   GtkStyleContext *context;
4723   gboolean parity;
4724
4725   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4726   context = gtk_widget_get_style_context (widget);
4727
4728   gtk_widget_style_get (widget,
4729                         "horizontal-separator", &horizontal_separator,
4730                         "vertical-separator", &vertical_separator,
4731                         "allow-rules", &allow_rules,
4732                         NULL);
4733
4734   if (tree_view->priv->tree == NULL)
4735     {
4736       draw_empty_focus (tree_view, cr);
4737       return TRUE;
4738     }
4739
4740   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
4741   bin_window_height = gdk_window_get_height (tree_view->priv->bin_window);
4742   cairo_rectangle (cr, 0, 0, bin_window_width, bin_window_height);
4743   cairo_clip (cr);
4744   if (!gdk_cairo_get_clip_rectangle (cr, &clip))
4745     return TRUE;
4746
4747   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, clip.y);
4748
4749   if (new_y < 0)
4750     new_y = 0;
4751   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4752
4753   if (tree_view->priv->height < bin_window_height)
4754     {
4755       gtk_style_context_save (context);
4756       gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4757
4758       gtk_render_background (context, cr,
4759                              0, tree_view->priv->height,
4760                              bin_window_width,
4761                              bin_window_height - tree_view->priv->height);
4762
4763       gtk_style_context_restore (context);
4764     }
4765
4766   if (node == NULL)
4767     return TRUE;
4768
4769   /* find the path for the node */
4770   path = _gtk_tree_path_new_from_rbtree (tree, node);
4771   gtk_tree_model_get_iter (tree_view->priv->model,
4772                            &iter,
4773                            path);
4774   depth = gtk_tree_path_get_depth (path);
4775   gtk_tree_path_free (path);
4776
4777   drag_dest_path = NULL;
4778
4779   if (tree_view->priv->drag_dest_row)
4780     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4781
4782   if (drag_dest_path)
4783     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4784                               &drag_highlight_tree, &drag_highlight);
4785
4786   draw_vgrid_lines =
4787     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4788     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4789   draw_hgrid_lines =
4790     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4791     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4792   expander_size = gtk_tree_view_get_expander_size (tree_view);
4793
4794   if (draw_vgrid_lines || draw_hgrid_lines)
4795     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4796
4797   n_visible_columns = 0;
4798   for (list = tree_view->priv->columns; list; list = list->next)
4799     {
4800       if (!gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
4801         continue;
4802       n_visible_columns ++;
4803     }
4804
4805   /* Find the last column */
4806   for (last_column = g_list_last (tree_view->priv->columns);
4807        last_column &&
4808        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
4809        last_column = last_column->prev)
4810     ;
4811
4812   /* and the first */
4813   for (first_column = g_list_first (tree_view->priv->columns);
4814        first_column &&
4815        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
4816        first_column = first_column->next)
4817     ;
4818
4819   /* Actually process the expose event.  To do this, we want to
4820    * start at the first node of the event, and walk the tree in
4821    * order, drawing each successive node.
4822    */
4823
4824   parity = !(_gtk_rbtree_node_get_index (tree, node) % 2);
4825
4826   do
4827     {
4828       gboolean is_separator = FALSE;
4829       gboolean is_first = FALSE;
4830       gboolean is_last = FALSE;
4831       gint n_col = 0;
4832
4833       parity = !parity;
4834       is_separator = row_is_separator (tree_view, &iter, NULL);
4835
4836       max_height = gtk_tree_view_get_row_height (tree_view, node);
4837
4838       cell_offset = 0;
4839       highlight_x = 0; /* should match x coord of first cell */
4840       expander_cell_width = 0;
4841
4842       background_area.y = y_offset + clip.y;
4843       background_area.height = max_height;
4844
4845       flags = 0;
4846
4847       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4848         flags |= GTK_CELL_RENDERER_PRELIT;
4849
4850       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4851         flags |= GTK_CELL_RENDERER_SELECTED;
4852
4853       /* we *need* to set cell data on all cells before the call
4854        * to _has_can_focus_cell, else _has_can_focus_cell() does not
4855        * return a correct value.
4856        */
4857       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4858            list;
4859            list = (rtl ? list->prev : list->next))
4860         {
4861           GtkTreeViewColumn *column = list->data;
4862           gtk_tree_view_column_cell_set_cell_data (column,
4863                                                    tree_view->priv->model,
4864                                                    &iter,
4865                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4866                                                    node->children?TRUE:FALSE);
4867         }
4868
4869       has_can_focus_cell = gtk_tree_view_has_can_focus_cell (tree_view);
4870
4871       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4872            list;
4873            list = (rtl ? list->prev : list->next))
4874         {
4875           GtkTreeViewColumn *column = list->data;
4876           GtkRegionFlags row_flags = 0, column_flags = 0;
4877           GtkStateFlags state = 0;
4878           gint width;
4879           gboolean draw_focus;
4880
4881           if (!gtk_tree_view_column_get_visible (column))
4882             continue;
4883
4884           n_col++;
4885           width = gtk_tree_view_column_get_width (column);
4886
4887           if (cell_offset > clip.x + clip.width ||
4888               cell_offset + width < clip.x)
4889             {
4890               cell_offset += width;
4891               continue;
4892             }
4893
4894           if (gtk_tree_view_column_get_sort_indicator (column))
4895             flags |= GTK_CELL_RENDERER_SORTED;
4896           else
4897             flags &= ~GTK_CELL_RENDERER_SORTED;
4898
4899           if (tree_view->priv->cursor_node == node)
4900             flags |= GTK_CELL_RENDERER_FOCUSED;
4901           else
4902             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4903
4904           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
4905             flags |= GTK_CELL_RENDERER_EXPANDABLE;
4906           else
4907             flags &= ~GTK_CELL_RENDERER_EXPANDABLE;
4908
4909           if (node->children)
4910             flags |= GTK_CELL_RENDERER_EXPANDED;
4911           else
4912             flags &= ~GTK_CELL_RENDERER_EXPANDED;
4913
4914           background_area.x = cell_offset;
4915           background_area.width = width;
4916
4917           cell_area = background_area;
4918           cell_area.y += vertical_separator / 2;
4919           cell_area.x += horizontal_separator / 2;
4920           cell_area.height -= vertical_separator;
4921           cell_area.width -= horizontal_separator;
4922
4923           if (draw_vgrid_lines)
4924             {
4925               if (list == first_column)
4926                 {
4927                   cell_area.width -= grid_line_width / 2;
4928                 }
4929               else if (list == last_column)
4930                 {
4931                   cell_area.x += grid_line_width / 2;
4932                   cell_area.width -= grid_line_width / 2;
4933                 }
4934               else
4935                 {
4936                   cell_area.x += grid_line_width / 2;
4937                   cell_area.width -= grid_line_width;
4938                 }
4939             }
4940
4941           if (draw_hgrid_lines)
4942             {
4943               cell_area.y += grid_line_width / 2;
4944               cell_area.height -= grid_line_width;
4945             }
4946
4947           if (!gdk_rectangle_intersect (&clip, &background_area, NULL))
4948             {
4949               cell_offset += gtk_tree_view_column_get_width (column);
4950               continue;
4951             }
4952
4953           gtk_tree_view_column_cell_set_cell_data (column,
4954                                                    tree_view->priv->model,
4955                                                    &iter,
4956                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4957                                                    node->children?TRUE:FALSE);
4958
4959           /* Select the detail for drawing the cell.  relevant
4960            * factors are parity, sortedness, and whether to
4961            * display rules.
4962            */
4963           if (allow_rules && tree_view->priv->has_rules)
4964             {
4965               if (parity)
4966                 row_flags |= GTK_REGION_ODD;
4967               else
4968                 row_flags |= GTK_REGION_EVEN;
4969             }
4970
4971           if ((flags & GTK_CELL_RENDERER_SORTED) &&
4972               n_visible_columns >= 3)
4973             column_flags |= GTK_REGION_SORTED;
4974
4975           is_first = (rtl ? !list->next : !list->prev);
4976           is_last = (rtl ? !list->prev : !list->next);
4977
4978           if (is_first)
4979             column_flags |= GTK_REGION_FIRST;
4980
4981           if (is_last)
4982             column_flags |= GTK_REGION_LAST;
4983
4984           if ((n_col % 2) == 0)
4985             column_flags |= GTK_REGION_EVEN;
4986           else
4987             column_flags |= GTK_REGION_ODD;
4988
4989           gtk_style_context_save (context);
4990
4991           state = gtk_cell_renderer_get_state (NULL, widget, flags);
4992           gtk_style_context_set_state (context, state);
4993
4994           gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4995           gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
4996           gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, column_flags);
4997
4998           if (node == tree_view->priv->cursor_node && has_can_focus_cell
4999               && ((column == tree_view->priv->focus_column
5000                    && tree_view->priv->draw_keyfocus &&
5001                    gtk_widget_has_visible_focus (widget))
5002                   || (column == tree_view->priv->edited_column)))
5003             draw_focus = TRUE;
5004           else
5005             draw_focus = FALSE;
5006
5007           /* Draw background */
5008           gtk_render_background (context, cr,
5009                                  background_area.x,
5010                                  background_area.y,
5011                                  background_area.width,
5012                                  background_area.height);
5013
5014           /* Draw frame */
5015           gtk_render_frame (context, cr,
5016                             background_area.x,
5017                             background_area.y,
5018                             background_area.width,
5019                             background_area.height);
5020
5021           if (gtk_tree_view_is_expander_column (tree_view, column))
5022             {
5023               if (!rtl)
5024                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
5025               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
5026
5027               if (gtk_tree_view_draw_expanders (tree_view))
5028                 {
5029                   int expander_size = gtk_tree_view_get_expander_size (tree_view);
5030                   if (!rtl)
5031                     cell_area.x += depth * expander_size;
5032                   cell_area.width -= depth * expander_size;
5033                 }
5034
5035               /* If we have an expander column, the highlight underline
5036                * starts with that column, so that it indicates which
5037                * level of the tree we're dropping at.
5038                */
5039               highlight_x = cell_area.x;
5040               expander_cell_width = cell_area.width;
5041
5042               if (is_separator)
5043                 {
5044                   gtk_style_context_save (context);
5045                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5046
5047                   gtk_render_line (context, cr,
5048                                    cell_area.x,
5049                                    cell_area.y + cell_area.height / 2,
5050                                    cell_area.x + cell_area.width,
5051                                    cell_area.y + cell_area.height / 2);
5052
5053                   gtk_style_context_restore (context);
5054                 }
5055               else
5056                 {
5057                   _gtk_tree_view_column_cell_render (column,
5058                                                      cr,
5059                                                      &background_area,
5060                                                      &cell_area,
5061                                                      flags,
5062                                                      draw_focus);
5063                 }
5064
5065               if (gtk_tree_view_draw_expanders (tree_view)
5066                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
5067                 {
5068                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
5069                                             cr,
5070                                             tree,
5071                                             node);
5072                 }
5073             }
5074           else
5075             {
5076               if (is_separator)
5077                 {
5078                   gtk_style_context_save (context);
5079                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5080
5081                   gtk_render_line (context, cr,
5082                                    cell_area.x,
5083                                    cell_area.y + cell_area.height / 2,
5084                                    cell_area.x + cell_area.width,
5085                                    cell_area.y + cell_area.height / 2);
5086
5087                   gtk_style_context_restore (context);
5088                 }
5089               else
5090                 _gtk_tree_view_column_cell_render (column,
5091                                                    cr,
5092                                                    &background_area,
5093                                                    &cell_area,
5094                                                    flags,
5095                                                    draw_focus);
5096             }
5097
5098           if (draw_hgrid_lines)
5099             {
5100               if (background_area.y > 0)
5101                 gtk_tree_view_draw_line (tree_view, cr,
5102                                          GTK_TREE_VIEW_GRID_LINE,
5103                                          background_area.x, background_area.y,
5104                                          background_area.x + background_area.width,
5105                                          background_area.y);
5106
5107               if (y_offset + max_height >= clip.height)
5108                 gtk_tree_view_draw_line (tree_view, cr,
5109                                          GTK_TREE_VIEW_GRID_LINE,
5110                                          background_area.x, background_area.y + max_height,
5111                                          background_area.x + background_area.width,
5112                                          background_area.y + max_height);
5113             }
5114
5115           if (gtk_tree_view_is_expander_column (tree_view, column) &&
5116               tree_view->priv->tree_lines_enabled)
5117             {
5118               gint x = background_area.x;
5119               gint mult = rtl ? -1 : 1;
5120               gint y0 = background_area.y;
5121               gint y1 = background_area.y + background_area.height/2;
5122               gint y2 = background_area.y + background_area.height;
5123
5124               if (rtl)
5125                 x += background_area.width - 1;
5126
5127               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
5128                   && depth > 1)
5129                 {
5130                   gtk_tree_view_draw_line (tree_view, cr,
5131                                            GTK_TREE_VIEW_TREE_LINE,
5132                                            x + expander_size * (depth - 1.5) * mult,
5133                                            y1,
5134                                            x + expander_size * (depth - 1.1) * mult,
5135                                            y1);
5136                 }
5137               else if (depth > 1)
5138                 {
5139                   gtk_tree_view_draw_line (tree_view, cr,
5140                                            GTK_TREE_VIEW_TREE_LINE,
5141                                            x + expander_size * (depth - 1.5) * mult,
5142                                            y1,
5143                                            x + expander_size * (depth - 0.5) * mult,
5144                                            y1);
5145                 }
5146
5147               if (depth > 1)
5148                 {
5149                   gint i;
5150                   GtkRBNode *tmp_node;
5151                   GtkRBTree *tmp_tree;
5152
5153                   if (!_gtk_rbtree_next (tree, node))
5154                     gtk_tree_view_draw_line (tree_view, cr,
5155                                              GTK_TREE_VIEW_TREE_LINE,
5156                                              x + expander_size * (depth - 1.5) * mult,
5157                                              y0,
5158                                              x + expander_size * (depth - 1.5) * mult,
5159                                              y1);
5160                   else
5161                     gtk_tree_view_draw_line (tree_view, cr,
5162                                              GTK_TREE_VIEW_TREE_LINE,
5163                                              x + expander_size * (depth - 1.5) * mult,
5164                                              y0,
5165                                              x + expander_size * (depth - 1.5) * mult,
5166                                              y2);
5167
5168                   tmp_node = tree->parent_node;
5169                   tmp_tree = tree->parent_tree;
5170
5171                   for (i = depth - 2; i > 0; i--)
5172                     {
5173                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
5174                         gtk_tree_view_draw_line (tree_view, cr,
5175                                                  GTK_TREE_VIEW_TREE_LINE,
5176                                                  x + expander_size * (i - 0.5) * mult,
5177                                                  y0,
5178                                                  x + expander_size * (i - 0.5) * mult,
5179                                                  y2);
5180
5181                       tmp_node = tmp_tree->parent_node;
5182                       tmp_tree = tmp_tree->parent_tree;
5183                     }
5184                 }
5185             }
5186
5187           gtk_style_context_restore (context);
5188           cell_offset += gtk_tree_view_column_get_width (column);
5189         }
5190
5191       if (node == drag_highlight)
5192         {
5193           /* Draw indicator for the drop
5194            */
5195           gint highlight_y = -1;
5196           GtkRBTree *tree = NULL;
5197           GtkRBNode *node = NULL;
5198
5199           gtk_style_context_save (context);
5200           gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND);
5201
5202           switch (tree_view->priv->drag_dest_pos)
5203             {
5204             case GTK_TREE_VIEW_DROP_BEFORE:
5205               highlight_y = background_area.y - 1;
5206               if (highlight_y < 0)
5207                       highlight_y = 0;
5208               break;
5209
5210             case GTK_TREE_VIEW_DROP_AFTER:
5211               highlight_y = background_area.y + background_area.height - 1;
5212               break;
5213
5214             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
5215             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
5216               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
5217
5218               if (tree == NULL)
5219                 break;
5220
5221               gtk_render_frame (context, cr,
5222                                 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node),
5223                                 gdk_window_get_width (tree_view->priv->bin_window),
5224                                 gtk_tree_view_get_row_height (tree_view, node));
5225               break;
5226             }
5227
5228           if (highlight_y >= 0)
5229             {
5230               gtk_tree_view_draw_line (tree_view, cr,
5231                                        GTK_TREE_VIEW_FOREGROUND_LINE,
5232                                        rtl ? highlight_x + expander_cell_width : highlight_x,
5233                                        highlight_y,
5234                                        rtl ? 0 : bin_window_width,
5235                                        highlight_y);
5236             }
5237
5238           gtk_style_context_restore (context);
5239         }
5240
5241       /* draw the big row-spanning focus rectangle, if needed */
5242       if (!has_can_focus_cell && node == tree_view->priv->cursor_node &&
5243           tree_view->priv->draw_keyfocus &&
5244           gtk_widget_has_visible_focus (widget))
5245         {
5246           gint tmp_y, tmp_height;
5247           GtkStateFlags focus_rect_state = 0;
5248
5249           gtk_style_context_save (context);
5250
5251           focus_rect_state = gtk_cell_renderer_get_state (NULL, widget, flags);
5252           gtk_style_context_set_state (context, focus_rect_state);
5253
5254           if (draw_hgrid_lines)
5255             {
5256               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node) + grid_line_width / 2;
5257               tmp_height = gtk_tree_view_get_row_height (tree_view, node) - grid_line_width;
5258             }
5259           else
5260             {
5261               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
5262               tmp_height = gtk_tree_view_get_row_height (tree_view, node);
5263             }
5264
5265           gtk_render_focus (context, cr,
5266                             0, tmp_y,
5267                             gdk_window_get_width (tree_view->priv->bin_window),
5268                             tmp_height);
5269
5270           gtk_style_context_restore (context);
5271         }
5272
5273       y_offset += max_height;
5274       if (node->children)
5275         {
5276           GtkTreeIter parent = iter;
5277           gboolean has_child;
5278
5279           tree = node->children;
5280           node = _gtk_rbtree_first (tree);
5281
5282           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
5283                                                     &iter,
5284                                                     &parent);
5285           depth++;
5286
5287           /* Sanity Check! */
5288           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
5289         }
5290       else
5291         {
5292           gboolean done = FALSE;
5293
5294           do
5295             {
5296               node = _gtk_rbtree_next (tree, node);
5297               if (node != NULL)
5298                 {
5299                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
5300                   done = TRUE;
5301
5302                   /* Sanity Check! */
5303                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
5304                 }
5305               else
5306                 {
5307                   GtkTreeIter parent_iter = iter;
5308                   gboolean has_parent;
5309
5310                   node = tree->parent_node;
5311                   tree = tree->parent_tree;
5312                   if (tree == NULL)
5313                     /* we should go to done to free some memory */
5314                     goto done;
5315                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
5316                                                            &iter,
5317                                                            &parent_iter);
5318                   depth--;
5319
5320                   /* Sanity check */
5321                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
5322                 }
5323             }
5324           while (!done);
5325         }
5326     }
5327   while (y_offset < clip.height);
5328
5329 done:
5330   gtk_tree_view_draw_grid_lines (tree_view, cr, n_visible_columns);
5331
5332   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
5333     gtk_tree_view_paint_rubber_band (tree_view, cr);
5334
5335   if (drag_dest_path)
5336     gtk_tree_path_free (drag_dest_path);
5337
5338   return FALSE;
5339 }
5340
5341 static gboolean
5342 gtk_tree_view_draw (GtkWidget *widget,
5343                     cairo_t   *cr)
5344 {
5345   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5346   GtkWidget   *button;
5347
5348   if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
5349     {
5350       GtkStyleContext *context;
5351       GList *tmp_list;
5352
5353       context = gtk_widget_get_style_context (widget);
5354
5355       cairo_save (cr);
5356
5357       gtk_style_context_save (context);
5358       gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
5359
5360       gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
5361
5362       gtk_tree_view_bin_draw (widget, cr);
5363
5364       gtk_style_context_restore (context);
5365       cairo_restore (cr);
5366
5367       /* We can't just chain up to Container::draw as it will try to send the
5368        * event to the headers, so we handle propagating it to our children
5369        * (eg. widgets being edited) ourselves.
5370        */
5371       tmp_list = tree_view->priv->children;
5372       while (tmp_list)
5373         {
5374           GtkTreeViewChild *child = tmp_list->data;
5375           tmp_list = tmp_list->next;
5376
5377           gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
5378         }
5379     }
5380
5381   if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
5382     {
5383       GList *list;
5384
5385       for (list = tree_view->priv->columns; list != NULL; list = list->next)
5386         {
5387           GtkTreeViewColumn *column = list->data;
5388
5389           if (column == tree_view->priv->drag_column)
5390             continue;
5391
5392           if (gtk_tree_view_column_get_visible (column))
5393             {
5394               button = gtk_tree_view_column_get_button (column);
5395               gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5396                                             button, cr);
5397             }
5398         }
5399     }
5400
5401   if (tree_view->priv->drag_window &&
5402       gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
5403     {
5404       button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
5405       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5406                                     button, cr);
5407     }
5408
5409   return FALSE;
5410 }
5411
5412 enum
5413 {
5414   DROP_HOME,
5415   DROP_RIGHT,
5416   DROP_LEFT,
5417   DROP_END
5418 };
5419
5420 /* returns 0x1 when no column has been found -- yes it's hackish */
5421 static GtkTreeViewColumn *
5422 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5423                                GtkTreeViewColumn *column,
5424                                gint               drop_position)
5425 {
5426   GtkTreeViewColumn *left_column = NULL;
5427   GtkTreeViewColumn *cur_column = NULL;
5428   GList *tmp_list;
5429
5430   if (!gtk_tree_view_column_get_reorderable (column))
5431     return (GtkTreeViewColumn *)0x1;
5432
5433   switch (drop_position)
5434     {
5435       case DROP_HOME:
5436         /* find first column where we can drop */
5437         tmp_list = tree_view->priv->columns;
5438         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5439           return (GtkTreeViewColumn *)0x1;
5440
5441         while (tmp_list)
5442           {
5443             g_assert (tmp_list);
5444
5445             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5446             tmp_list = tmp_list->next;
5447
5448             if (left_column &&
5449                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5450               continue;
5451
5452             if (!tree_view->priv->column_drop_func)
5453               return left_column;
5454
5455             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5456               {
5457                 left_column = cur_column;
5458                 continue;
5459               }
5460
5461             return left_column;
5462           }
5463
5464         if (!tree_view->priv->column_drop_func)
5465           return left_column;
5466
5467         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5468           return left_column;
5469         else
5470           return (GtkTreeViewColumn *)0x1;
5471         break;
5472
5473       case DROP_RIGHT:
5474         /* find first column after column where we can drop */
5475         tmp_list = tree_view->priv->columns;
5476
5477         for (; tmp_list; tmp_list = tmp_list->next)
5478           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5479             break;
5480
5481         if (!tmp_list || !tmp_list->next)
5482           return (GtkTreeViewColumn *)0x1;
5483
5484         tmp_list = tmp_list->next;
5485         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5486         tmp_list = tmp_list->next;
5487
5488         while (tmp_list)
5489           {
5490             g_assert (tmp_list);
5491
5492             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5493             tmp_list = tmp_list->next;
5494
5495             if (left_column &&
5496                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5497               {
5498                 left_column = cur_column;
5499                 if (tmp_list)
5500                   tmp_list = tmp_list->next;
5501                 continue;
5502               }
5503
5504             if (!tree_view->priv->column_drop_func)
5505               return left_column;
5506
5507             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5508               {
5509                 left_column = cur_column;
5510                 continue;
5511               }
5512
5513             return left_column;
5514           }
5515
5516         if (!tree_view->priv->column_drop_func)
5517           return left_column;
5518
5519         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5520           return left_column;
5521         else
5522           return (GtkTreeViewColumn *)0x1;
5523         break;
5524
5525       case DROP_LEFT:
5526         /* find first column before column where we can drop */
5527         tmp_list = tree_view->priv->columns;
5528
5529         for (; tmp_list; tmp_list = tmp_list->next)
5530           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5531             break;
5532
5533         if (!tmp_list || !tmp_list->prev)
5534           return (GtkTreeViewColumn *)0x1;
5535
5536         tmp_list = tmp_list->prev;
5537         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5538         tmp_list = tmp_list->prev;
5539
5540         while (tmp_list)
5541           {
5542             g_assert (tmp_list);
5543
5544             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5545
5546             if (left_column &&
5547                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5548               {
5549                 /*if (!tmp_list->prev)
5550                   return (GtkTreeViewColumn *)0x1;
5551                   */
5552 /*
5553                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5554                 tmp_list = tmp_list->prev->prev;
5555                 continue;*/
5556
5557                 cur_column = left_column;
5558                 if (tmp_list)
5559                   tmp_list = tmp_list->prev;
5560                 continue;
5561               }
5562
5563             if (!tree_view->priv->column_drop_func)
5564               return left_column;
5565
5566             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5567               return left_column;
5568
5569             cur_column = left_column;
5570             tmp_list = tmp_list->prev;
5571           }
5572
5573         if (!tree_view->priv->column_drop_func)
5574           return NULL;
5575
5576         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5577           return NULL;
5578         else
5579           return (GtkTreeViewColumn *)0x1;
5580         break;
5581
5582       case DROP_END:
5583         /* same as DROP_HOME case, but doing it backwards */
5584         tmp_list = g_list_last (tree_view->priv->columns);
5585         cur_column = NULL;
5586
5587         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5588           return (GtkTreeViewColumn *)0x1;
5589
5590         while (tmp_list)
5591           {
5592             g_assert (tmp_list);
5593
5594             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5595
5596             if (left_column &&
5597                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5598               {
5599                 cur_column = left_column;
5600                 tmp_list = tmp_list->prev;
5601               }
5602
5603             if (!tree_view->priv->column_drop_func)
5604               return left_column;
5605
5606             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5607               return left_column;
5608
5609             cur_column = left_column;
5610             tmp_list = tmp_list->prev;
5611           }
5612
5613         if (!tree_view->priv->column_drop_func)
5614           return NULL;
5615
5616         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5617           return NULL;
5618         else
5619           return (GtkTreeViewColumn *)0x1;
5620         break;
5621     }
5622
5623   return (GtkTreeViewColumn *)0x1;
5624 }
5625
5626 static gboolean
5627 gtk_tree_view_key_press (GtkWidget   *widget,
5628                          GdkEventKey *event)
5629 {
5630   GtkTreeView *tree_view = (GtkTreeView *) widget;
5631   GtkWidget   *button;
5632
5633   if (tree_view->priv->rubber_band_status)
5634     {
5635       if (event->keyval == GDK_KEY_Escape)
5636         gtk_tree_view_stop_rubber_band (tree_view);
5637
5638       return TRUE;
5639     }
5640
5641   if (tree_view->priv->in_column_drag)
5642     {
5643       if (event->keyval == GDK_KEY_Escape)
5644         {
5645           tree_view->priv->cur_reorder = NULL;
5646           gtk_tree_view_button_release_drag_column (widget, NULL);
5647         }
5648       return TRUE;
5649     }
5650
5651   if (tree_view->priv->headers_visible)
5652     {
5653       GList *focus_column;
5654       gboolean rtl;
5655
5656       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5657
5658       for (focus_column = tree_view->priv->columns;
5659            focus_column;
5660            focus_column = focus_column->next)
5661         {
5662           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5663
5664           button = gtk_tree_view_column_get_button (column);
5665           if (gtk_widget_has_focus (button))
5666             break;
5667         }
5668
5669       if (focus_column &&
5670           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5671           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5672            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right))
5673         {
5674           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5675           gint max_width, min_width;
5676
5677           if (!gtk_tree_view_column_get_resizable (column))
5678             {
5679               gtk_widget_error_bell (widget);
5680               return TRUE;
5681             }
5682
5683           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5684               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5685             {
5686               GtkRequisition button_req;
5687               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5688               gint new_width;
5689
5690               button = gtk_tree_view_column_get_button (column);
5691
5692               gtk_widget_get_preferred_size (button, &button_req, NULL);
5693
5694               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5695               new_width -= 2;
5696               if (new_width < 0)
5697                 new_width = 0;
5698
5699               _gtk_tree_view_column_set_resized_width (column, new_width);
5700
5701               min_width = gtk_tree_view_column_get_min_width (column);
5702               if (min_width == -1)
5703                 new_width = MAX (button_req.width, new_width);
5704               else
5705                 {
5706                   new_width = MAX (min_width, new_width);
5707                 }
5708
5709               max_width = gtk_tree_view_column_get_max_width (column);
5710               if (max_width != -1)
5711                 new_width = MIN (new_width, max_width);
5712
5713               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5714
5715               if (new_width != old_width)
5716                 {
5717                   _gtk_tree_view_column_set_resized_width (column, new_width);
5718                   gtk_widget_queue_resize (widget);
5719                 }
5720               else
5721                 gtk_widget_error_bell (widget);
5722             }
5723           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5724                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5725             {
5726               gint old_width = _gtk_tree_view_column_get_resized_width (column);
5727               gint new_width;
5728
5729               new_width = MAX (old_width, gtk_tree_view_column_get_width (column));
5730               new_width += 2;
5731
5732               max_width = gtk_tree_view_column_get_max_width (column);
5733               if (max_width != -1)
5734                 new_width = MIN (new_width, max_width);
5735
5736               _gtk_tree_view_column_set_use_resized_width (column, TRUE);
5737
5738               if (new_width != old_width)
5739                 {
5740                   _gtk_tree_view_column_set_resized_width (column, new_width);
5741                   gtk_widget_queue_resize (widget);
5742                 }
5743               else
5744                 gtk_widget_error_bell (widget);
5745             }
5746
5747           return TRUE;
5748         }
5749
5750       if (focus_column &&
5751           (event->state & GDK_MOD1_MASK) &&
5752           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5753            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right
5754            || event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home
5755            || event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End))
5756         {
5757           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5758
5759           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5760               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5761             {
5762               GtkTreeViewColumn *col;
5763               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5764               if (col != (GtkTreeViewColumn *)0x1)
5765                 gtk_tree_view_move_column_after (tree_view, column, col);
5766               else
5767                 gtk_widget_error_bell (widget);
5768             }
5769           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5770                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5771             {
5772               GtkTreeViewColumn *col;
5773               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5774               if (col != (GtkTreeViewColumn *)0x1)
5775                 gtk_tree_view_move_column_after (tree_view, column, col);
5776               else
5777                 gtk_widget_error_bell (widget);
5778             }
5779           else if (event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home)
5780             {
5781               GtkTreeViewColumn *col;
5782               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5783               if (col != (GtkTreeViewColumn *)0x1)
5784                 gtk_tree_view_move_column_after (tree_view, column, col);
5785               else
5786                 gtk_widget_error_bell (widget);
5787             }
5788           else if (event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
5789             {
5790               GtkTreeViewColumn *col;
5791               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
5792               if (col != (GtkTreeViewColumn *)0x1)
5793                 gtk_tree_view_move_column_after (tree_view, column, col);
5794               else
5795                 gtk_widget_error_bell (widget);
5796             }
5797
5798           return TRUE;
5799         }
5800     }
5801
5802   /* Chain up to the parent class.  It handles the keybindings. */
5803   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5804     return TRUE;
5805
5806   if (tree_view->priv->search_entry_avoid_unhandled_binding)
5807     {
5808       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
5809       return FALSE;
5810     }
5811
5812   /* We pass the event to the search_entry.  If its text changes, then we start
5813    * the typeahead find capabilities. */
5814   if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
5815       && tree_view->priv->enable_search
5816       && !tree_view->priv->search_custom_entry_set)
5817     {
5818       GdkEvent *new_event;
5819       char *old_text;
5820       const char *new_text;
5821       gboolean retval;
5822       GdkScreen *screen;
5823       gboolean text_modified;
5824       gulong popup_menu_id;
5825
5826       gtk_tree_view_ensure_interactive_directory (tree_view);
5827
5828       /* Make a copy of the current text */
5829       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5830       new_event = gdk_event_copy ((GdkEvent *) event);
5831       g_object_unref (((GdkEventKey *) new_event)->window);
5832       ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
5833       gtk_widget_realize (tree_view->priv->search_window);
5834
5835       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5836                                         "popup-menu", G_CALLBACK (gtk_true),
5837                                         NULL);
5838
5839       /* Move the entry off screen */
5840       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5841       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5842                        gdk_screen_get_width (screen) + 1,
5843                        gdk_screen_get_height (screen) + 1);
5844       gtk_widget_show (tree_view->priv->search_window);
5845
5846       /* Send the event to the window.  If the preedit_changed signal is emitted
5847        * during this event, we will set priv->imcontext_changed  */
5848       tree_view->priv->imcontext_changed = FALSE;
5849       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5850       gdk_event_free (new_event);
5851       gtk_widget_hide (tree_view->priv->search_window);
5852
5853       g_signal_handler_disconnect (tree_view->priv->search_entry,
5854                                    popup_menu_id);
5855
5856       /* We check to make sure that the entry tried to handle the text, and that
5857        * the text has changed.
5858        */
5859       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5860       text_modified = strcmp (old_text, new_text) != 0;
5861       g_free (old_text);
5862       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5863           (retval && text_modified))               /* ...or the text was modified */
5864         {
5865           if (gtk_tree_view_real_start_interactive_search (tree_view,
5866                                                            gdk_event_get_device ((GdkEvent *) event),
5867                                                            FALSE))
5868             {
5869               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5870               return TRUE;
5871             }
5872           else
5873             {
5874               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5875               return FALSE;
5876             }
5877         }
5878     }
5879
5880   return FALSE;
5881 }
5882
5883 static gboolean
5884 gtk_tree_view_key_release (GtkWidget   *widget,
5885                            GdkEventKey *event)
5886 {
5887   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5888
5889   if (tree_view->priv->rubber_band_status)
5890     return TRUE;
5891
5892   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5893 }
5894
5895 /* FIXME Is this function necessary? Can I get an enter_notify event
5896  * w/o either an expose event or a mouse motion event?
5897  */
5898 static gboolean
5899 gtk_tree_view_enter_notify (GtkWidget        *widget,
5900                             GdkEventCrossing *event)
5901 {
5902   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5903   GtkRBTree *tree;
5904   GtkRBNode *node;
5905   gint new_y;
5906
5907   /* Sanity check it */
5908   if (event->window != tree_view->priv->bin_window)
5909     return FALSE;
5910
5911   if (tree_view->priv->tree == NULL)
5912     return FALSE;
5913
5914   if (event->mode == GDK_CROSSING_GRAB ||
5915       event->mode == GDK_CROSSING_GTK_GRAB ||
5916       event->mode == GDK_CROSSING_GTK_UNGRAB ||
5917       event->mode == GDK_CROSSING_STATE_CHANGED)
5918     return TRUE;
5919
5920   /* find the node internally */
5921   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5922   if (new_y < 0)
5923     new_y = 0;
5924   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5925
5926   tree_view->priv->event_last_x = event->x;
5927   tree_view->priv->event_last_y = event->y;
5928
5929   if ((tree_view->priv->button_pressed_node == NULL) ||
5930       (tree_view->priv->button_pressed_node == node))
5931     prelight_or_select (tree_view, tree, node, event->x, event->y);
5932
5933   return TRUE;
5934 }
5935
5936 static gboolean
5937 gtk_tree_view_leave_notify (GtkWidget        *widget,
5938                             GdkEventCrossing *event)
5939 {
5940   GtkTreeView *tree_view;
5941
5942   if (event->mode == GDK_CROSSING_GRAB ||
5943       event->mode == GDK_CROSSING_GTK_GRAB ||
5944       event->mode == GDK_CROSSING_GTK_UNGRAB)
5945     return TRUE;
5946
5947   tree_view = GTK_TREE_VIEW (widget);
5948
5949   if (tree_view->priv->prelight_node)
5950     _gtk_tree_view_queue_draw_node (tree_view,
5951                                    tree_view->priv->prelight_tree,
5952                                    tree_view->priv->prelight_node,
5953                                    NULL);
5954
5955   tree_view->priv->event_last_x = -10000;
5956   tree_view->priv->event_last_y = -10000;
5957
5958   prelight_or_select (tree_view,
5959                       NULL, NULL,
5960                       -1000, -1000); /* coords not possibly over an arrow */
5961
5962   return TRUE;
5963 }
5964
5965
5966 static gint
5967 gtk_tree_view_focus_out (GtkWidget     *widget,
5968                          GdkEventFocus *event)
5969 {
5970   GtkTreeView *tree_view;
5971
5972   tree_view = GTK_TREE_VIEW (widget);
5973
5974   gtk_widget_queue_draw (widget);
5975
5976   /* destroy interactive search dialog */
5977   if (tree_view->priv->search_window)
5978     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
5979                                       gdk_event_get_device ((GdkEvent *) event));
5980
5981   return FALSE;
5982 }
5983
5984
5985 /* Incremental Reflow
5986  */
5987
5988 static void
5989 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
5990                                  GtkRBTree   *tree,
5991                                  GtkRBNode   *node)
5992 {
5993   GtkAllocation allocation;
5994   gint y;
5995
5996   y = _gtk_rbtree_node_find_offset (tree, node)
5997     - gtk_adjustment_get_value (tree_view->priv->vadjustment)
5998     + gtk_tree_view_get_effective_header_height (tree_view);
5999
6000   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
6001   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
6002                               0, y,
6003                               allocation.width,
6004                               GTK_RBNODE_GET_HEIGHT (node));
6005 }
6006
6007 static gboolean
6008 node_is_visible (GtkTreeView *tree_view,
6009                  GtkRBTree   *tree,
6010                  GtkRBNode   *node)
6011 {
6012   int y;
6013   int height;
6014
6015   y = _gtk_rbtree_node_find_offset (tree, node);
6016   height = gtk_tree_view_get_row_height (tree_view, node);
6017
6018   if (y >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6019       y + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6020                      + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6021     return TRUE;
6022
6023   return FALSE;
6024 }
6025
6026 /* Returns TRUE if it updated the size
6027  */
6028 static gboolean
6029 validate_row (GtkTreeView *tree_view,
6030               GtkRBTree   *tree,
6031               GtkRBNode   *node,
6032               GtkTreeIter *iter,
6033               GtkTreePath *path)
6034 {
6035   GtkTreeViewColumn *column;
6036   GList *list, *first_column, *last_column;
6037   gint height = 0;
6038   gint horizontal_separator;
6039   gint vertical_separator;
6040   gint depth = gtk_tree_path_get_depth (path);
6041   gboolean retval = FALSE;
6042   gboolean is_separator = FALSE;
6043   gboolean draw_vgrid_lines, draw_hgrid_lines;
6044   gint focus_pad;
6045   gint grid_line_width;
6046   gboolean wide_separators;
6047   gint separator_height;
6048   gint expander_size;
6049
6050   /* double check the row needs validating */
6051   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
6052       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6053     return FALSE;
6054
6055   is_separator = row_is_separator (tree_view, iter, NULL);
6056
6057   gtk_widget_style_get (GTK_WIDGET (tree_view),
6058                         "focus-padding", &focus_pad,
6059                         "horizontal-separator", &horizontal_separator,
6060                         "vertical-separator", &vertical_separator,
6061                         "grid-line-width", &grid_line_width,
6062                         "wide-separators",  &wide_separators,
6063                         "separator-height", &separator_height,
6064                         NULL);
6065
6066   draw_vgrid_lines =
6067     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
6068     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6069   draw_hgrid_lines =
6070     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
6071     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6072   expander_size = gtk_tree_view_get_expander_size (tree_view);
6073
6074   for (last_column = g_list_last (tree_view->priv->columns);
6075        last_column &&
6076        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
6077        last_column = last_column->prev)
6078     ;
6079
6080   for (first_column = g_list_first (tree_view->priv->columns);
6081        first_column &&
6082        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
6083        first_column = first_column->next)
6084     ;
6085
6086   for (list = tree_view->priv->columns; list; list = list->next)
6087     {
6088       gint padding = 0;
6089       gint original_width;
6090       gint new_width;
6091       gint row_height;
6092
6093       column = list->data;
6094
6095       if (!gtk_tree_view_column_get_visible (column))
6096         continue;
6097
6098       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) &&
6099           !_gtk_tree_view_column_cell_get_dirty (column))
6100         continue;
6101
6102       original_width = _gtk_tree_view_column_get_requested_width (column);
6103
6104       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
6105                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
6106                                                node->children?TRUE:FALSE);
6107       gtk_tree_view_column_cell_get_size (column,
6108                                           NULL, NULL, NULL,
6109                                           NULL, &row_height);
6110
6111       if (!is_separator)
6112         {
6113           row_height += vertical_separator;
6114           height = MAX (height, row_height);
6115           height = MAX (height, expander_size);
6116         }
6117       else
6118         {
6119           if (wide_separators)
6120             height = separator_height + 2 * focus_pad;
6121           else
6122             height = 2 + 2 * focus_pad;
6123         }
6124
6125       if (gtk_tree_view_is_expander_column (tree_view, column))
6126         {
6127           padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
6128
6129           if (gtk_tree_view_draw_expanders (tree_view))
6130             padding += depth * expander_size;
6131         }
6132       else
6133         padding += horizontal_separator;
6134
6135       if (draw_vgrid_lines)
6136         {
6137           if (list->data == first_column || list->data == last_column)
6138             padding += grid_line_width / 2.0;
6139           else
6140             padding += grid_line_width;
6141         }
6142
6143       /* Update the padding for the column */
6144       _gtk_tree_view_column_push_padding (column, padding);
6145       new_width = _gtk_tree_view_column_get_requested_width (column);
6146
6147       if (new_width > original_width)
6148         retval = TRUE;
6149     }
6150
6151   if (draw_hgrid_lines)
6152     height += grid_line_width;
6153
6154   if (height != GTK_RBNODE_GET_HEIGHT (node))
6155     {
6156       retval = TRUE;
6157       _gtk_rbtree_node_set_height (tree, node, height);
6158     }
6159   _gtk_rbtree_node_mark_valid (tree, node);
6160   tree_view->priv->post_validation_flag = TRUE;
6161
6162   return retval;
6163 }
6164
6165
6166 static void
6167 validate_visible_area (GtkTreeView *tree_view)
6168 {
6169   GtkAllocation allocation;
6170   GtkTreePath *path = NULL;
6171   GtkTreePath *above_path = NULL;
6172   GtkTreeIter iter;
6173   GtkRBTree *tree = NULL;
6174   GtkRBNode *node = NULL;
6175   gboolean need_redraw = FALSE;
6176   gboolean size_changed = FALSE;
6177   gint total_height;
6178   gint area_above = 0;
6179   gint area_below = 0;
6180
6181   if (tree_view->priv->tree == NULL)
6182     return;
6183
6184   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
6185       tree_view->priv->scroll_to_path == NULL)
6186     return;
6187
6188   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
6189   total_height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
6190
6191   if (total_height == 0)
6192     return;
6193
6194   /* First, we check to see if we need to scroll anywhere
6195    */
6196   if (tree_view->priv->scroll_to_path)
6197     {
6198       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
6199       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
6200         {
6201           /* we are going to scroll, and will update dy */
6202           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6203           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6204               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6205             {
6206               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6207               if (validate_row (tree_view, tree, node, &iter, path))
6208                 size_changed = TRUE;
6209             }
6210
6211           if (tree_view->priv->scroll_to_use_align)
6212             {
6213               gint height = gtk_tree_view_get_row_height (tree_view, node);
6214               area_above = (total_height - height) *
6215                 tree_view->priv->scroll_to_row_align;
6216               area_below = total_height - area_above - height;
6217               area_above = MAX (area_above, 0);
6218               area_below = MAX (area_below, 0);
6219             }
6220           else
6221             {
6222               /* two cases:
6223                * 1) row not visible
6224                * 2) row visible
6225                */
6226               gint dy;
6227               gint height = gtk_tree_view_get_row_height (tree_view, node);
6228
6229               dy = _gtk_rbtree_node_find_offset (tree, node);
6230
6231               if (dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6232                   dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6233                                   + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6234                 {
6235                   /* row visible: keep the row at the same position */
6236                   area_above = dy - gtk_adjustment_get_value (tree_view->priv->vadjustment);
6237                   area_below = (gtk_adjustment_get_value (tree_view->priv->vadjustment) +
6238                                 gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6239                                - dy - height;
6240                 }
6241               else
6242                 {
6243                   /* row not visible */
6244                   if (dy >= 0
6245                       && dy + height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6246                     {
6247                       /* row at the beginning -- fixed */
6248                       area_above = dy;
6249                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment)
6250                                    - area_above - height;
6251                     }
6252                   else if (dy >= (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6253                                   gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6254                     {
6255                       /* row at the end -- fixed */
6256                       area_above = dy - (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6257                                    gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6258                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) -
6259                                    area_above - height;
6260
6261                       if (area_below < 0)
6262                         {
6263                           area_above = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - height;
6264                           area_below = 0;
6265                         }
6266                     }
6267                   else
6268                     {
6269                       /* row somewhere in the middle, bring it to the top
6270                        * of the view
6271                        */
6272                       area_above = 0;
6273                       area_below = total_height - height;
6274                     }
6275                 }
6276             }
6277         }
6278       else
6279         /* the scroll to isn't valid; ignore it.
6280          */
6281         {
6282           if (tree_view->priv->scroll_to_path && !path)
6283             {
6284               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6285               tree_view->priv->scroll_to_path = NULL;
6286             }
6287           if (path)
6288             gtk_tree_path_free (path);
6289           path = NULL;
6290         }
6291     }
6292
6293   /* We didn't have a scroll_to set, so we just handle things normally
6294    */
6295   if (path == NULL)
6296     {
6297       gint offset;
6298
6299       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6300                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
6301                                         &tree, &node);
6302       if (node == NULL)
6303         {
6304           /* In this case, nothing has been validated */
6305           path = gtk_tree_path_new_first ();
6306           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6307         }
6308       else
6309         {
6310           path = _gtk_tree_path_new_from_rbtree (tree, node);
6311           total_height += offset;
6312         }
6313
6314       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6315
6316       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6317           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6318         {
6319           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6320           if (validate_row (tree_view, tree, node, &iter, path))
6321             size_changed = TRUE;
6322         }
6323       area_above = 0;
6324       area_below = total_height - gtk_tree_view_get_row_height (tree_view, node);
6325     }
6326
6327   above_path = gtk_tree_path_copy (path);
6328
6329   /* if we do not validate any row above the new top_row, we will make sure
6330    * that the row immediately above top_row has been validated. (if we do not
6331    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
6332    * when invalidated that row's height will be zero. and this will mess up
6333    * scrolling).
6334    */
6335   if (area_above == 0)
6336     {
6337       GtkRBTree *tmptree;
6338       GtkRBNode *tmpnode;
6339
6340       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
6341       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
6342
6343       if (tmpnode)
6344         {
6345           GtkTreePath *tmppath;
6346           GtkTreeIter tmpiter;
6347
6348           tmppath = _gtk_tree_path_new_from_rbtree (tmptree, tmpnode);
6349           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
6350
6351           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
6352               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
6353             {
6354               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
6355               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
6356                 size_changed = TRUE;
6357             }
6358
6359           gtk_tree_path_free (tmppath);
6360         }
6361     }
6362
6363   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
6364    * backwards is much slower then forward, as there is no iter_prev function.
6365    * We go forwards first in case we run out of tree.  Then we go backwards to
6366    * fill out the top.
6367    */
6368   while (node && area_below > 0)
6369     {
6370       if (node->children)
6371         {
6372           GtkTreeIter parent = iter;
6373           gboolean has_child;
6374
6375           tree = node->children;
6376           node = _gtk_rbtree_first (tree);
6377
6378           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
6379                                                     &iter,
6380                                                     &parent);
6381           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
6382           gtk_tree_path_down (path);
6383         }
6384       else
6385         {
6386           gboolean done = FALSE;
6387           do
6388             {
6389               node = _gtk_rbtree_next (tree, node);
6390               if (node != NULL)
6391                 {
6392                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
6393                   done = TRUE;
6394                   gtk_tree_path_next (path);
6395
6396                   /* Sanity Check! */
6397                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
6398                 }
6399               else
6400                 {
6401                   GtkTreeIter parent_iter = iter;
6402                   gboolean has_parent;
6403
6404                   node = tree->parent_node;
6405                   tree = tree->parent_tree;
6406                   if (tree == NULL)
6407                     break;
6408                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
6409                                                            &iter,
6410                                                            &parent_iter);
6411                   gtk_tree_path_up (path);
6412
6413                   /* Sanity check */
6414                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
6415                 }
6416             }
6417           while (!done);
6418         }
6419
6420       if (!node)
6421         break;
6422
6423       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6424           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6425         {
6426           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6427           if (validate_row (tree_view, tree, node, &iter, path))
6428               size_changed = TRUE;
6429         }
6430
6431       area_below -= gtk_tree_view_get_row_height (tree_view, node);
6432     }
6433   gtk_tree_path_free (path);
6434
6435   /* If we ran out of tree, and have extra area_below left, we need to add it
6436    * to area_above */
6437   if (area_below > 0)
6438     area_above += area_below;
6439
6440   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
6441
6442   /* We walk backwards */
6443   while (area_above > 0)
6444     {
6445       _gtk_rbtree_prev_full (tree, node, &tree, &node);
6446
6447       /* Always find the new path in the tree.  We cannot just assume
6448        * a gtk_tree_path_prev() is enough here, as there might be children
6449        * in between this node and the previous sibling node.  If this
6450        * appears to be a performance hotspot in profiles, we can look into
6451        * intrigate logic for keeping path, node and iter in sync like
6452        * we do for forward walks.  (Which will be hard because of the lacking
6453        * iter_prev).
6454        */
6455
6456       if (node == NULL)
6457         break;
6458
6459       gtk_tree_path_free (above_path);
6460       above_path = _gtk_tree_path_new_from_rbtree (tree, node);
6461
6462       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
6463
6464       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6465           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6466         {
6467           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6468           if (validate_row (tree_view, tree, node, &iter, above_path))
6469             size_changed = TRUE;
6470         }
6471       area_above -= gtk_tree_view_get_row_height (tree_view, node);
6472     }
6473
6474   /* if we scrolled to a path, we need to set the dy here,
6475    * and sync the top row accordingly
6476    */
6477   if (tree_view->priv->scroll_to_path)
6478     {
6479       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6480       gtk_tree_view_top_row_to_dy (tree_view);
6481
6482       need_redraw = TRUE;
6483     }
6484   else if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6485     {
6486       /* when we are not scrolling, we should never set dy to something
6487        * else than zero. we update top_row to be in sync with dy = 0.
6488        */
6489       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6490       gtk_tree_view_dy_to_top_row (tree_view);
6491     }
6492   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6493     {
6494       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6495       gtk_tree_view_dy_to_top_row (tree_view);
6496     }
6497   else
6498     gtk_tree_view_top_row_to_dy (tree_view);
6499
6500   /* update width/height and queue a resize */
6501   if (size_changed)
6502     {
6503       GtkRequisition requisition;
6504
6505       /* We temporarily guess a size, under the assumption that it will be the
6506        * same when we get our next size_allocate.  If we don't do this, we'll be
6507        * in an inconsistent state if we call top_row_to_dy. */
6508
6509       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6510                                      &requisition, NULL);
6511       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6512                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6513       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6514                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6515       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6516     }
6517
6518   if (tree_view->priv->scroll_to_path)
6519     {
6520       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6521       tree_view->priv->scroll_to_path = NULL;
6522     }
6523
6524   if (above_path)
6525     gtk_tree_path_free (above_path);
6526
6527   if (tree_view->priv->scroll_to_column)
6528     {
6529       tree_view->priv->scroll_to_column = NULL;
6530     }
6531   if (need_redraw)
6532     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6533 }
6534
6535 static void
6536 initialize_fixed_height_mode (GtkTreeView *tree_view)
6537 {
6538   if (!tree_view->priv->tree)
6539     return;
6540
6541   if (tree_view->priv->fixed_height < 0)
6542     {
6543       GtkTreeIter iter;
6544       GtkTreePath *path;
6545
6546       GtkRBTree *tree = NULL;
6547       GtkRBNode *node = NULL;
6548
6549       tree = tree_view->priv->tree;
6550       node = tree->root;
6551
6552       path = _gtk_tree_path_new_from_rbtree (tree, node);
6553       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6554
6555       validate_row (tree_view, tree, node, &iter, path);
6556
6557       gtk_tree_path_free (path);
6558
6559       tree_view->priv->fixed_height = gtk_tree_view_get_row_height (tree_view, node);
6560     }
6561
6562    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6563                                  tree_view->priv->fixed_height, TRUE);
6564 }
6565
6566 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6567  * the left-most uninvalidated node.  We then try walking right, validating
6568  * nodes.  Once we find a valid node, we repeat the previous process of finding
6569  * the first invalid node.
6570  */
6571
6572 static gboolean
6573 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6574 {
6575   GtkRBTree *tree = NULL;
6576   GtkRBNode *node = NULL;
6577   gboolean validated_area = FALSE;
6578   gint retval = TRUE;
6579   GtkTreePath *path = NULL;
6580   GtkTreeIter iter;
6581   GTimer *timer;
6582   gint i = 0;
6583
6584   gint y = -1;
6585   gint prev_height = -1;
6586   gboolean fixed_height = TRUE;
6587
6588   g_assert (tree_view);
6589
6590   if (tree_view->priv->tree == NULL)
6591       return FALSE;
6592
6593   if (tree_view->priv->fixed_height_mode)
6594     {
6595       if (tree_view->priv->fixed_height < 0)
6596         initialize_fixed_height_mode (tree_view);
6597
6598       return FALSE;
6599     }
6600
6601   timer = g_timer_new ();
6602   g_timer_start (timer);
6603
6604   do
6605     {
6606       gboolean changed = FALSE;
6607
6608       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6609         {
6610           retval = FALSE;
6611           goto done;
6612         }
6613
6614       if (path != NULL)
6615         {
6616           node = _gtk_rbtree_next (tree, node);
6617           if (node != NULL)
6618             {
6619               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6620               gtk_tree_path_next (path);
6621             }
6622           else
6623             {
6624               gtk_tree_path_free (path);
6625               path = NULL;
6626             }
6627         }
6628
6629       if (path == NULL)
6630         {
6631           tree = tree_view->priv->tree;
6632           node = tree_view->priv->tree->root;
6633
6634           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6635
6636           do
6637             {
6638               if (!_gtk_rbtree_is_nil (node->left) &&
6639                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6640                 {
6641                   node = node->left;
6642                 }
6643               else if (!_gtk_rbtree_is_nil (node->right) &&
6644                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6645                 {
6646                   node = node->right;
6647                 }
6648               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6649                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6650                 {
6651                   break;
6652                 }
6653               else if (node->children != NULL)
6654                 {
6655                   tree = node->children;
6656                   node = tree->root;
6657                 }
6658               else
6659                 /* RBTree corruption!  All bad */
6660                 g_assert_not_reached ();
6661             }
6662           while (TRUE);
6663           path = _gtk_tree_path_new_from_rbtree (tree, node);
6664           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6665         }
6666
6667       changed = validate_row (tree_view, tree, node, &iter, path);
6668       validated_area = changed || validated_area;
6669
6670       if (changed)
6671         {
6672           gint offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
6673
6674           if (y == -1 || y > offset)
6675             y = offset;
6676         }
6677
6678       if (!tree_view->priv->fixed_height_check)
6679         {
6680           gint height;
6681
6682           height = gtk_tree_view_get_row_height (tree_view, node);
6683           if (prev_height < 0)
6684             prev_height = height;
6685           else if (prev_height != height)
6686             fixed_height = FALSE;
6687         }
6688
6689       i++;
6690     }
6691   while (g_timer_elapsed (timer, NULL) < GTK_TREE_VIEW_TIME_MS_PER_IDLE / 1000.);
6692
6693   if (!tree_view->priv->fixed_height_check)
6694    {
6695      if (fixed_height)
6696        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6697
6698      tree_view->priv->fixed_height_check = 1;
6699    }
6700
6701  done:
6702   if (validated_area)
6703     {
6704       GtkRequisition requisition;
6705
6706       /* We temporarily guess a size, under the assumption that it will be the
6707        * same when we get our next size_allocate.  If we don't do this, we'll be
6708        * in an inconsistent state when we call top_row_to_dy. */
6709
6710       /* FIXME: This is called from size_request, for some reason it is not infinitely
6711        * recursing, we cannot call gtk_widget_get_preferred_size() here because that's
6712        * not allowed (from inside ->get_preferred_width/height() implementations, one
6713        * should call the vfuncs directly). However what is desired here is the full
6714        * size including any margins and limited by any alignment (i.e. after
6715        * GtkWidget:adjust_size_request() is called).
6716        *
6717        * Currently bypassing this but the real solution is to not update the scroll adjustments
6718        * untill we've recieved an allocation (never update scroll adjustments from size-requests).
6719        */
6720       gtk_tree_view_size_request (GTK_WIDGET (tree_view), &requisition, FALSE);
6721
6722       /* If rows above the current position have changed height, this has
6723        * affected the current view and thus needs a redraw.
6724        */
6725       if (y != -1 && y < gtk_adjustment_get_value (tree_view->priv->vadjustment))
6726         gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6727
6728       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6729                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6730       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6731                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6732
6733       if (queue_resize)
6734         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
6735     }
6736
6737   if (path) gtk_tree_path_free (path);
6738   g_timer_destroy (timer);
6739
6740   return retval;
6741 }
6742
6743 static gboolean
6744 validate_rows (GtkTreeView *tree_view)
6745 {
6746   gboolean retval;
6747
6748   retval = do_validate_rows (tree_view, TRUE);
6749
6750   if (! retval && tree_view->priv->validate_rows_timer)
6751     {
6752       g_source_remove (tree_view->priv->validate_rows_timer);
6753       tree_view->priv->validate_rows_timer = 0;
6754     }
6755
6756   return retval;
6757 }
6758
6759 static gboolean
6760 validate_rows_handler (GtkTreeView *tree_view)
6761 {
6762   gboolean retval;
6763
6764   retval = do_validate_rows (tree_view, TRUE);
6765   if (! retval && tree_view->priv->validate_rows_timer)
6766     {
6767       g_source_remove (tree_view->priv->validate_rows_timer);
6768       tree_view->priv->validate_rows_timer = 0;
6769     }
6770
6771   return retval;
6772 }
6773
6774 static gboolean
6775 do_presize_handler (GtkTreeView *tree_view)
6776 {
6777   if (tree_view->priv->mark_rows_col_dirty)
6778     {
6779       if (tree_view->priv->tree)
6780         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6781       tree_view->priv->mark_rows_col_dirty = FALSE;
6782     }
6783   validate_visible_area (tree_view);
6784   tree_view->priv->presize_handler_timer = 0;
6785
6786   if (tree_view->priv->fixed_height_mode)
6787     {
6788       GtkRequisition requisition;
6789
6790       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6791                                      &requisition, NULL);
6792
6793       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6794                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6795       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6796                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6797       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6798     }
6799
6800   return FALSE;
6801 }
6802
6803 static gboolean
6804 presize_handler_callback (gpointer data)
6805 {
6806   do_presize_handler (GTK_TREE_VIEW (data));
6807
6808   return FALSE;
6809 }
6810
6811 static void
6812 install_presize_handler (GtkTreeView *tree_view)
6813 {
6814   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6815     return;
6816
6817   if (! tree_view->priv->presize_handler_timer)
6818     {
6819       tree_view->priv->presize_handler_timer =
6820         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6821     }
6822   if (! tree_view->priv->validate_rows_timer)
6823     {
6824       tree_view->priv->validate_rows_timer =
6825         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6826     }
6827 }
6828
6829 static gboolean
6830 scroll_sync_handler (GtkTreeView *tree_view)
6831 {
6832   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6833     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6834   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6835     gtk_tree_view_top_row_to_dy (tree_view);
6836   else
6837     gtk_tree_view_dy_to_top_row (tree_view);
6838
6839   tree_view->priv->scroll_sync_timer = 0;
6840
6841   return FALSE;
6842 }
6843
6844 static void
6845 install_scroll_sync_handler (GtkTreeView *tree_view)
6846 {
6847   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6848     return;
6849
6850   if (!tree_view->priv->scroll_sync_timer)
6851     {
6852       tree_view->priv->scroll_sync_timer =
6853         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6854     }
6855 }
6856
6857 static void
6858 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6859                            GtkTreePath *path,
6860                            gint         offset)
6861 {
6862   gtk_tree_row_reference_free (tree_view->priv->top_row);
6863
6864   if (!path)
6865     {
6866       tree_view->priv->top_row = NULL;
6867       tree_view->priv->top_row_dy = 0;
6868     }
6869   else
6870     {
6871       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6872       tree_view->priv->top_row_dy = offset;
6873     }
6874 }
6875
6876 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6877  * it's set to be NULL, and top_row_dy is 0;
6878  */
6879 static void
6880 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6881 {
6882   gint offset;
6883   GtkTreePath *path;
6884   GtkRBTree *tree;
6885   GtkRBNode *node;
6886
6887   if (tree_view->priv->tree == NULL)
6888     {
6889       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6890     }
6891   else
6892     {
6893       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6894                                         tree_view->priv->dy,
6895                                         &tree, &node);
6896
6897       if (tree == NULL)
6898         {
6899           gtk_tree_view_set_top_row (tree_view, NULL, 0);
6900         }
6901       else
6902         {
6903           path = _gtk_tree_path_new_from_rbtree (tree, node);
6904           gtk_tree_view_set_top_row (tree_view, path, offset);
6905           gtk_tree_path_free (path);
6906         }
6907     }
6908 }
6909
6910 static void
6911 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6912 {
6913   GtkTreePath *path;
6914   GtkRBTree *tree;
6915   GtkRBNode *node;
6916   int new_dy;
6917
6918   /* Avoid recursive calls */
6919   if (tree_view->priv->in_top_row_to_dy)
6920     return;
6921
6922   if (tree_view->priv->top_row)
6923     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6924   else
6925     path = NULL;
6926
6927   if (!path)
6928     tree = NULL;
6929   else
6930     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6931
6932   if (path)
6933     gtk_tree_path_free (path);
6934
6935   if (tree == NULL)
6936     {
6937       /* keep dy and set new toprow */
6938       gtk_tree_row_reference_free (tree_view->priv->top_row);
6939       tree_view->priv->top_row = NULL;
6940       tree_view->priv->top_row_dy = 0;
6941       /* DO NOT install the idle handler */
6942       gtk_tree_view_dy_to_top_row (tree_view);
6943       return;
6944     }
6945
6946   if (gtk_tree_view_get_row_height (tree_view, node)
6947       < tree_view->priv->top_row_dy)
6948     {
6949       /* new top row -- do NOT install the idle handler */
6950       gtk_tree_view_dy_to_top_row (tree_view);
6951       return;
6952     }
6953
6954   new_dy = _gtk_rbtree_node_find_offset (tree, node);
6955   new_dy += tree_view->priv->top_row_dy;
6956
6957   if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6958     new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
6959
6960   new_dy = MAX (0, new_dy);
6961
6962   tree_view->priv->in_top_row_to_dy = TRUE;
6963   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
6964   tree_view->priv->in_top_row_to_dy = FALSE;
6965 }
6966
6967
6968 void
6969 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view,
6970                                             gboolean     install_handler)
6971 {
6972   tree_view->priv->mark_rows_col_dirty = TRUE;
6973
6974   if (install_handler)
6975     install_presize_handler (tree_view);
6976 }
6977
6978 /*
6979  * This function works synchronously (due to the while (validate_rows...)
6980  * loop).
6981  *
6982  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
6983  * here. You now need to check that yourself.
6984  */
6985 void
6986 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
6987                                 GtkTreeViewColumn *column)
6988 {
6989   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6990   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
6991
6992   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
6993
6994   do_presize_handler (tree_view);
6995   while (validate_rows (tree_view));
6996
6997   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6998 }
6999
7000 /* Drag-and-drop */
7001
7002 static void
7003 set_source_row (GdkDragContext *context,
7004                 GtkTreeModel   *model,
7005                 GtkTreePath    *source_row)
7006 {
7007   g_object_set_data_full (G_OBJECT (context),
7008                           I_("gtk-tree-view-source-row"),
7009                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
7010                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
7011 }
7012
7013 static GtkTreePath*
7014 get_source_row (GdkDragContext *context)
7015 {
7016   GtkTreeRowReference *ref =
7017     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
7018
7019   if (ref)
7020     return gtk_tree_row_reference_get_path (ref);
7021   else
7022     return NULL;
7023 }
7024
7025 typedef struct
7026 {
7027   GtkTreeRowReference *dest_row;
7028   guint                path_down_mode   : 1;
7029   guint                empty_view_drop  : 1;
7030   guint                drop_append_mode : 1;
7031 }
7032 DestRow;
7033
7034 static void
7035 dest_row_free (gpointer data)
7036 {
7037   DestRow *dr = (DestRow *)data;
7038
7039   gtk_tree_row_reference_free (dr->dest_row);
7040   g_slice_free (DestRow, dr);
7041 }
7042
7043 static void
7044 set_dest_row (GdkDragContext *context,
7045               GtkTreeModel   *model,
7046               GtkTreePath    *dest_row,
7047               gboolean        path_down_mode,
7048               gboolean        empty_view_drop,
7049               gboolean        drop_append_mode)
7050 {
7051   DestRow *dr;
7052
7053   if (!dest_row)
7054     {
7055       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7056                               NULL, NULL);
7057       return;
7058     }
7059
7060   dr = g_slice_new (DestRow);
7061
7062   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
7063   dr->path_down_mode = path_down_mode != FALSE;
7064   dr->empty_view_drop = empty_view_drop != FALSE;
7065   dr->drop_append_mode = drop_append_mode != FALSE;
7066
7067   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7068                           dr, (GDestroyNotify) dest_row_free);
7069 }
7070
7071 static GtkTreePath*
7072 get_dest_row (GdkDragContext *context,
7073               gboolean       *path_down_mode)
7074 {
7075   DestRow *dr =
7076     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
7077
7078   if (dr)
7079     {
7080       GtkTreePath *path = NULL;
7081
7082       if (path_down_mode)
7083         *path_down_mode = dr->path_down_mode;
7084
7085       if (dr->dest_row)
7086         path = gtk_tree_row_reference_get_path (dr->dest_row);
7087       else if (dr->empty_view_drop)
7088         path = gtk_tree_path_new_from_indices (0, -1);
7089       else
7090         path = NULL;
7091
7092       if (path && dr->drop_append_mode)
7093         gtk_tree_path_next (path);
7094
7095       return path;
7096     }
7097   else
7098     return NULL;
7099 }
7100
7101 /* Get/set whether drag_motion requested the drag data and
7102  * drag_data_received should thus not actually insert the data,
7103  * since the data doesn't result from a drop.
7104  */
7105 static void
7106 set_status_pending (GdkDragContext *context,
7107                     GdkDragAction   suggested_action)
7108 {
7109   g_object_set_data (G_OBJECT (context),
7110                      I_("gtk-tree-view-status-pending"),
7111                      GINT_TO_POINTER (suggested_action));
7112 }
7113
7114 static GdkDragAction
7115 get_status_pending (GdkDragContext *context)
7116 {
7117   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
7118                                              "gtk-tree-view-status-pending"));
7119 }
7120
7121 static TreeViewDragInfo*
7122 get_info (GtkTreeView *tree_view)
7123 {
7124   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
7125 }
7126
7127 static void
7128 destroy_info (TreeViewDragInfo *di)
7129 {
7130   g_slice_free (TreeViewDragInfo, di);
7131 }
7132
7133 static TreeViewDragInfo*
7134 ensure_info (GtkTreeView *tree_view)
7135 {
7136   TreeViewDragInfo *di;
7137
7138   di = get_info (tree_view);
7139
7140   if (di == NULL)
7141     {
7142       di = g_slice_new0 (TreeViewDragInfo);
7143
7144       g_object_set_data_full (G_OBJECT (tree_view),
7145                               I_("gtk-tree-view-drag-info"),
7146                               di,
7147                               (GDestroyNotify) destroy_info);
7148     }
7149
7150   return di;
7151 }
7152
7153 static void
7154 remove_info (GtkTreeView *tree_view)
7155 {
7156   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
7157 }
7158
7159 #if 0
7160 static gint
7161 drag_scan_timeout (gpointer data)
7162 {
7163   GtkTreeView *tree_view;
7164   gint x, y;
7165   GdkModifierType state;
7166   GtkTreePath *path = NULL;
7167   GtkTreeViewColumn *column = NULL;
7168   GdkRectangle visible_rect;
7169
7170   gdk_threads_enter ();
7171
7172   tree_view = GTK_TREE_VIEW (data);
7173
7174   gdk_window_get_device_position (tree_view->priv->bin_window,
7175                                   gdk_device_manager_get_client_pointer (
7176                                     gdk_display_get_device_manager (
7177                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
7178                                   &x, &y, &state);
7179
7180   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
7181
7182   /* See if we are near the edge. */
7183   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
7184       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
7185       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
7186       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
7187     {
7188       gtk_tree_view_get_path_at_pos (tree_view,
7189                                      tree_view->priv->bin_window,
7190                                      x, y,
7191                                      &path,
7192                                      &column,
7193                                      NULL,
7194                                      NULL);
7195
7196       if (path != NULL)
7197         {
7198           gtk_tree_view_scroll_to_cell (tree_view,
7199                                         path,
7200                                         column,
7201                                         TRUE,
7202                                         0.5, 0.5);
7203
7204           gtk_tree_path_free (path);
7205         }
7206     }
7207
7208   gdk_threads_leave ();
7209
7210   return TRUE;
7211 }
7212 #endif /* 0 */
7213
7214 static void
7215 add_scroll_timeout (GtkTreeView *tree_view)
7216 {
7217   if (tree_view->priv->scroll_timeout == 0)
7218     {
7219       tree_view->priv->scroll_timeout =
7220         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
7221     }
7222 }
7223
7224 static void
7225 remove_scroll_timeout (GtkTreeView *tree_view)
7226 {
7227   if (tree_view->priv->scroll_timeout != 0)
7228     {
7229       g_source_remove (tree_view->priv->scroll_timeout);
7230       tree_view->priv->scroll_timeout = 0;
7231     }
7232 }
7233
7234 static gboolean
7235 check_model_dnd (GtkTreeModel *model,
7236                  GType         required_iface,
7237                  const gchar  *signal)
7238 {
7239   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
7240     {
7241       g_warning ("You must override the default '%s' handler "
7242                  "on GtkTreeView when using models that don't support "
7243                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
7244                  "is to connect to '%s' and call "
7245                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
7246                  "the default handler from running. Look at the source code "
7247                  "for the default handler in gtktreeview.c to get an idea what "
7248                  "your handler should do. (gtktreeview.c is in the GTK source "
7249                  "code.) If you're using GTK from a language other than C, "
7250                  "there may be a more natural way to override default handlers, e.g. via derivation.",
7251                  signal, g_type_name (required_iface), signal);
7252       return FALSE;
7253     }
7254   else
7255     return TRUE;
7256 }
7257
7258 static void
7259 remove_open_timeout (GtkTreeView *tree_view)
7260 {
7261   if (tree_view->priv->open_dest_timeout != 0)
7262     {
7263       g_source_remove (tree_view->priv->open_dest_timeout);
7264       tree_view->priv->open_dest_timeout = 0;
7265     }
7266 }
7267
7268
7269 static gint
7270 open_row_timeout (gpointer data)
7271 {
7272   GtkTreeView *tree_view = data;
7273   GtkTreePath *dest_path = NULL;
7274   GtkTreeViewDropPosition pos;
7275   gboolean result = FALSE;
7276
7277   gtk_tree_view_get_drag_dest_row (tree_view,
7278                                    &dest_path,
7279                                    &pos);
7280
7281   if (dest_path &&
7282       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7283        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7284     {
7285       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
7286       tree_view->priv->open_dest_timeout = 0;
7287
7288       gtk_tree_path_free (dest_path);
7289     }
7290   else
7291     {
7292       if (dest_path)
7293         gtk_tree_path_free (dest_path);
7294
7295       result = TRUE;
7296     }
7297
7298   return result;
7299 }
7300
7301 static gboolean
7302 scroll_row_timeout (gpointer data)
7303 {
7304   GtkTreeView *tree_view = data;
7305
7306   gtk_tree_view_vertical_autoscroll (tree_view);
7307
7308   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
7309     gtk_tree_view_update_rubber_band (tree_view);
7310
7311   return TRUE;
7312 }
7313
7314 /* Returns TRUE if event should not be propagated to parent widgets */
7315 static gboolean
7316 set_destination_row (GtkTreeView    *tree_view,
7317                      GdkDragContext *context,
7318                      /* coordinates relative to the widget */
7319                      gint            x,
7320                      gint            y,
7321                      GdkDragAction  *suggested_action,
7322                      GdkAtom        *target)
7323 {
7324   GtkTreePath *path = NULL;
7325   GtkTreeViewDropPosition pos;
7326   GtkTreeViewDropPosition old_pos;
7327   TreeViewDragInfo *di;
7328   GtkWidget *widget;
7329   GtkTreePath *old_dest_path = NULL;
7330   gboolean can_drop = FALSE;
7331
7332   *suggested_action = 0;
7333   *target = GDK_NONE;
7334
7335   widget = GTK_WIDGET (tree_view);
7336
7337   di = get_info (tree_view);
7338
7339   if (di == NULL || y - gtk_tree_view_get_effective_header_height (tree_view) < 0)
7340     {
7341       /* someone unset us as a drag dest, note that if
7342        * we return FALSE drag_leave isn't called
7343        */
7344
7345       gtk_tree_view_set_drag_dest_row (tree_view,
7346                                        NULL,
7347                                        GTK_TREE_VIEW_DROP_BEFORE);
7348
7349       remove_scroll_timeout (GTK_TREE_VIEW (widget));
7350       remove_open_timeout (GTK_TREE_VIEW (widget));
7351
7352       return FALSE; /* no longer a drop site */
7353     }
7354
7355   *target = gtk_drag_dest_find_target (widget, context,
7356                                        gtk_drag_dest_get_target_list (widget));
7357   if (*target == GDK_NONE)
7358     {
7359       return FALSE;
7360     }
7361
7362   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
7363                                           x, y,
7364                                           &path,
7365                                           &pos))
7366     {
7367       gint n_children;
7368       GtkTreeModel *model;
7369
7370       remove_open_timeout (tree_view);
7371
7372       /* the row got dropped on empty space, let's setup a special case
7373        */
7374
7375       if (path)
7376         gtk_tree_path_free (path);
7377
7378       model = gtk_tree_view_get_model (tree_view);
7379
7380       n_children = gtk_tree_model_iter_n_children (model, NULL);
7381       if (n_children)
7382         {
7383           pos = GTK_TREE_VIEW_DROP_AFTER;
7384           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
7385         }
7386       else
7387         {
7388           pos = GTK_TREE_VIEW_DROP_BEFORE;
7389           path = gtk_tree_path_new_from_indices (0, -1);
7390         }
7391
7392       can_drop = TRUE;
7393
7394       goto out;
7395     }
7396
7397   g_assert (path);
7398
7399   /* If we left the current row's "open" zone, unset the timeout for
7400    * opening the row
7401    */
7402   gtk_tree_view_get_drag_dest_row (tree_view,
7403                                    &old_dest_path,
7404                                    &old_pos);
7405
7406   if (old_dest_path &&
7407       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
7408        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7409          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
7410     remove_open_timeout (tree_view);
7411
7412   if (old_dest_path)
7413     gtk_tree_path_free (old_dest_path);
7414
7415   if (TRUE /* FIXME if the location droppable predicate */)
7416     {
7417       can_drop = TRUE;
7418     }
7419
7420 out:
7421   if (can_drop)
7422     {
7423       GtkWidget *source_widget;
7424
7425       *suggested_action = gdk_drag_context_get_suggested_action (context);
7426       source_widget = gtk_drag_get_source_widget (context);
7427
7428       if (source_widget == widget)
7429         {
7430           /* Default to MOVE, unless the user has
7431            * pressed ctrl or shift to affect available actions
7432            */
7433           if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
7434             *suggested_action = GDK_ACTION_MOVE;
7435         }
7436
7437       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7438                                        path, pos);
7439     }
7440   else
7441     {
7442       /* can't drop here */
7443       remove_open_timeout (tree_view);
7444
7445       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7446                                        NULL,
7447                                        GTK_TREE_VIEW_DROP_BEFORE);
7448     }
7449
7450   if (path)
7451     gtk_tree_path_free (path);
7452
7453   return TRUE;
7454 }
7455
7456 static GtkTreePath*
7457 get_logical_dest_row (GtkTreeView *tree_view,
7458                       gboolean    *path_down_mode,
7459                       gboolean    *drop_append_mode)
7460 {
7461   /* adjust path to point to the row the drop goes in front of */
7462   GtkTreePath *path = NULL;
7463   GtkTreeViewDropPosition pos;
7464
7465   g_return_val_if_fail (path_down_mode != NULL, NULL);
7466   g_return_val_if_fail (drop_append_mode != NULL, NULL);
7467
7468   *path_down_mode = FALSE;
7469   *drop_append_mode = 0;
7470
7471   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7472
7473   if (path == NULL)
7474     return NULL;
7475
7476   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
7477     ; /* do nothing */
7478   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
7479            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
7480     *path_down_mode = TRUE;
7481   else
7482     {
7483       GtkTreeIter iter;
7484       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
7485
7486       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
7487
7488       if (!gtk_tree_model_get_iter (model, &iter, path) ||
7489           !gtk_tree_model_iter_next (model, &iter))
7490         *drop_append_mode = 1;
7491       else
7492         {
7493           *drop_append_mode = 0;
7494           gtk_tree_path_next (path);
7495         }
7496     }
7497
7498   return path;
7499 }
7500
7501 static gboolean
7502 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
7503                                         GdkEventMotion   *event)
7504 {
7505   GtkWidget *widget = GTK_WIDGET (tree_view);
7506   GdkDragContext *context;
7507   TreeViewDragInfo *di;
7508   GtkTreePath *path = NULL;
7509   gint button;
7510   gint cell_x, cell_y;
7511   GtkTreeModel *model;
7512   gboolean retval = FALSE;
7513
7514   di = get_info (tree_view);
7515
7516   if (di == NULL || !di->source_set)
7517     goto out;
7518
7519   if (tree_view->priv->pressed_button < 0)
7520     goto out;
7521
7522   if (!gtk_drag_check_threshold (widget,
7523                                  tree_view->priv->press_start_x,
7524                                  tree_view->priv->press_start_y,
7525                                  event->x, event->y))
7526     goto out;
7527
7528   model = gtk_tree_view_get_model (tree_view);
7529
7530   if (model == NULL)
7531     goto out;
7532
7533   button = tree_view->priv->pressed_button;
7534   tree_view->priv->pressed_button = -1;
7535
7536   gtk_tree_view_get_path_at_pos (tree_view,
7537                                  tree_view->priv->press_start_x,
7538                                  tree_view->priv->press_start_y,
7539                                  &path,
7540                                  NULL,
7541                                  &cell_x,
7542                                  &cell_y);
7543
7544   if (path == NULL)
7545     goto out;
7546
7547   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7548       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7549                                            path))
7550     goto out;
7551
7552   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7553     goto out;
7554
7555   /* Now we can begin the drag */
7556
7557   retval = TRUE;
7558
7559   context = gtk_drag_begin (widget,
7560                             gtk_drag_source_get_target_list (widget),
7561                             di->source_actions,
7562                             button,
7563                             (GdkEvent*)event);
7564
7565   set_source_row (context, model, path);
7566
7567  out:
7568   if (path)
7569     gtk_tree_path_free (path);
7570
7571   return retval;
7572 }
7573
7574
7575 static void
7576 gtk_tree_view_drag_begin (GtkWidget      *widget,
7577                           GdkDragContext *context)
7578 {
7579   GtkTreeView *tree_view;
7580   GtkTreePath *path = NULL;
7581   gint cell_x, cell_y;
7582   cairo_surface_t *row_pix;
7583   TreeViewDragInfo *di;
7584
7585   tree_view = GTK_TREE_VIEW (widget);
7586
7587   /* if the user uses a custom DND source impl, we don't set the icon here */
7588   di = get_info (tree_view);
7589
7590   if (di == NULL || !di->source_set)
7591     return;
7592
7593   gtk_tree_view_get_path_at_pos (tree_view,
7594                                  tree_view->priv->press_start_x,
7595                                  tree_view->priv->press_start_y,
7596                                  &path,
7597                                  NULL,
7598                                  &cell_x,
7599                                  &cell_y);
7600
7601   /* If path is NULL, there's nothing we can drag.  For now, we silently
7602    * bail out.  Actually, dragging should not be possible from an empty
7603    * tree view, but there's no way we can cancel that from here.
7604    * Automatically unsetting the tree view as drag source for empty models
7605    * is something that would likely break other people's code ...
7606    */
7607   if (!path)
7608     return;
7609
7610   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7611                                                 path);
7612   cairo_surface_set_device_offset (row_pix,
7613                                    /* the + 1 is for the black border in the icon */
7614                                    - (tree_view->priv->press_start_x + 1),
7615                                    - (cell_y + 1));
7616
7617   gtk_drag_set_icon_surface (context, row_pix);
7618
7619   cairo_surface_destroy (row_pix);
7620   gtk_tree_path_free (path);
7621 }
7622
7623 static void
7624 gtk_tree_view_drag_end (GtkWidget      *widget,
7625                         GdkDragContext *context)
7626 {
7627   /* do nothing */
7628 }
7629
7630 /* Default signal implementations for the drag signals */
7631 static void
7632 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7633                              GdkDragContext   *context,
7634                              GtkSelectionData *selection_data,
7635                              guint             info,
7636                              guint             time)
7637 {
7638   GtkTreeView *tree_view;
7639   GtkTreeModel *model;
7640   TreeViewDragInfo *di;
7641   GtkTreePath *source_row;
7642
7643   tree_view = GTK_TREE_VIEW (widget);
7644
7645   model = gtk_tree_view_get_model (tree_view);
7646
7647   if (model == NULL)
7648     return;
7649
7650   di = get_info (GTK_TREE_VIEW (widget));
7651
7652   if (di == NULL)
7653     return;
7654
7655   source_row = get_source_row (context);
7656
7657   if (source_row == NULL)
7658     return;
7659
7660   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7661    * any model; for DragSource models there are some other targets
7662    * we also support.
7663    */
7664
7665   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7666       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7667                                           source_row,
7668                                           selection_data))
7669     goto done;
7670
7671   /* If drag_data_get does nothing, try providing row data. */
7672   if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7673     {
7674       gtk_tree_set_row_drag_data (selection_data,
7675                                   model,
7676                                   source_row);
7677     }
7678
7679  done:
7680   gtk_tree_path_free (source_row);
7681 }
7682
7683
7684 static void
7685 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7686                                 GdkDragContext *context)
7687 {
7688   TreeViewDragInfo *di;
7689   GtkTreeModel *model;
7690   GtkTreeView *tree_view;
7691   GtkTreePath *source_row;
7692
7693   tree_view = GTK_TREE_VIEW (widget);
7694   model = gtk_tree_view_get_model (tree_view);
7695
7696   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7697     return;
7698
7699   di = get_info (tree_view);
7700
7701   if (di == NULL)
7702     return;
7703
7704   source_row = get_source_row (context);
7705
7706   if (source_row == NULL)
7707     return;
7708
7709   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7710                                          source_row);
7711
7712   gtk_tree_path_free (source_row);
7713
7714   set_source_row (context, NULL, NULL);
7715 }
7716
7717 static void
7718 gtk_tree_view_drag_leave (GtkWidget      *widget,
7719                           GdkDragContext *context,
7720                           guint             time)
7721 {
7722   /* unset any highlight row */
7723   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7724                                    NULL,
7725                                    GTK_TREE_VIEW_DROP_BEFORE);
7726
7727   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7728   remove_open_timeout (GTK_TREE_VIEW (widget));
7729 }
7730
7731
7732 static gboolean
7733 gtk_tree_view_drag_motion (GtkWidget        *widget,
7734                            GdkDragContext   *context,
7735                            /* coordinates relative to the widget */
7736                            gint              x,
7737                            gint              y,
7738                            guint             time)
7739 {
7740   gboolean empty;
7741   GtkTreePath *path = NULL;
7742   GtkTreeViewDropPosition pos;
7743   GtkTreeView *tree_view;
7744   GdkDragAction suggested_action = 0;
7745   GdkAtom target;
7746
7747   tree_view = GTK_TREE_VIEW (widget);
7748
7749   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7750     return FALSE;
7751
7752   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7753
7754   /* we only know this *after* set_desination_row */
7755   empty = tree_view->priv->empty_view_drop;
7756
7757   if (path == NULL && !empty)
7758     {
7759       /* Can't drop here. */
7760       gdk_drag_status (context, 0, time);
7761     }
7762   else
7763     {
7764       if (tree_view->priv->open_dest_timeout == 0 &&
7765           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7766            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7767         {
7768           tree_view->priv->open_dest_timeout =
7769             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7770         }
7771       else
7772         {
7773           add_scroll_timeout (tree_view);
7774         }
7775
7776       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7777         {
7778           /* Request data so we can use the source row when
7779            * determining whether to accept the drop
7780            */
7781           set_status_pending (context, suggested_action);
7782           gtk_drag_get_data (widget, context, target, time);
7783         }
7784       else
7785         {
7786           set_status_pending (context, 0);
7787           gdk_drag_status (context, suggested_action, time);
7788         }
7789     }
7790
7791   if (path)
7792     gtk_tree_path_free (path);
7793
7794   return TRUE;
7795 }
7796
7797
7798 static gboolean
7799 gtk_tree_view_drag_drop (GtkWidget        *widget,
7800                          GdkDragContext   *context,
7801                          /* coordinates relative to the widget */
7802                          gint              x,
7803                          gint              y,
7804                          guint             time)
7805 {
7806   GtkTreeView *tree_view;
7807   GtkTreePath *path;
7808   GdkDragAction suggested_action = 0;
7809   GdkAtom target = GDK_NONE;
7810   TreeViewDragInfo *di;
7811   GtkTreeModel *model;
7812   gboolean path_down_mode;
7813   gboolean drop_append_mode;
7814
7815   tree_view = GTK_TREE_VIEW (widget);
7816
7817   model = gtk_tree_view_get_model (tree_view);
7818
7819   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7820   remove_open_timeout (GTK_TREE_VIEW (widget));
7821
7822   di = get_info (tree_view);
7823
7824   if (di == NULL)
7825     return FALSE;
7826
7827   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7828     return FALSE;
7829
7830   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7831     return FALSE;
7832
7833   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7834
7835   if (target != GDK_NONE && path != NULL)
7836     {
7837       /* in case a motion had requested drag data, change things so we
7838        * treat drag data receives as a drop.
7839        */
7840       set_status_pending (context, 0);
7841       set_dest_row (context, model, path,
7842                     path_down_mode, tree_view->priv->empty_view_drop,
7843                     drop_append_mode);
7844     }
7845
7846   if (path)
7847     gtk_tree_path_free (path);
7848
7849   /* Unset this thing */
7850   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7851                                    NULL,
7852                                    GTK_TREE_VIEW_DROP_BEFORE);
7853
7854   if (target != GDK_NONE)
7855     {
7856       gtk_drag_get_data (widget, context, target, time);
7857       return TRUE;
7858     }
7859   else
7860     return FALSE;
7861 }
7862
7863 static void
7864 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7865                                   GdkDragContext   *context,
7866                                   /* coordinates relative to the widget */
7867                                   gint              x,
7868                                   gint              y,
7869                                   GtkSelectionData *selection_data,
7870                                   guint             info,
7871                                   guint             time)
7872 {
7873   GtkTreePath *path;
7874   TreeViewDragInfo *di;
7875   gboolean accepted = FALSE;
7876   GtkTreeModel *model;
7877   GtkTreeView *tree_view;
7878   GtkTreePath *dest_row;
7879   GdkDragAction suggested_action;
7880   gboolean path_down_mode;
7881   gboolean drop_append_mode;
7882
7883   tree_view = GTK_TREE_VIEW (widget);
7884
7885   model = gtk_tree_view_get_model (tree_view);
7886
7887   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7888     return;
7889
7890   di = get_info (tree_view);
7891
7892   if (di == NULL)
7893     return;
7894
7895   suggested_action = get_status_pending (context);
7896
7897   if (suggested_action)
7898     {
7899       /* We are getting this data due to a request in drag_motion,
7900        * rather than due to a request in drag_drop, so we are just
7901        * supposed to call drag_status, not actually paste in the
7902        * data.
7903        */
7904       path = get_logical_dest_row (tree_view, &path_down_mode,
7905                                    &drop_append_mode);
7906
7907       if (path == NULL)
7908         suggested_action = 0;
7909       else if (path_down_mode)
7910         gtk_tree_path_down (path);
7911
7912       if (suggested_action)
7913         {
7914           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7915                                                      path,
7916                                                      selection_data))
7917             {
7918               if (path_down_mode)
7919                 {
7920                   path_down_mode = FALSE;
7921                   gtk_tree_path_up (path);
7922
7923                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7924                                                              path,
7925                                                              selection_data))
7926                     suggested_action = 0;
7927                 }
7928               else
7929                 suggested_action = 0;
7930             }
7931         }
7932
7933       gdk_drag_status (context, suggested_action, time);
7934
7935       if (path)
7936         gtk_tree_path_free (path);
7937
7938       /* If you can't drop, remove user drop indicator until the next motion */
7939       if (suggested_action == 0)
7940         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7941                                          NULL,
7942                                          GTK_TREE_VIEW_DROP_BEFORE);
7943
7944       return;
7945     }
7946
7947   dest_row = get_dest_row (context, &path_down_mode);
7948
7949   if (dest_row == NULL)
7950     return;
7951
7952   if (gtk_selection_data_get_length (selection_data) >= 0)
7953     {
7954       if (path_down_mode)
7955         {
7956           gtk_tree_path_down (dest_row);
7957           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7958                                                      dest_row, selection_data))
7959             gtk_tree_path_up (dest_row);
7960         }
7961     }
7962
7963   if (gtk_selection_data_get_length (selection_data) >= 0)
7964     {
7965       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
7966                                                  dest_row,
7967                                                  selection_data))
7968         accepted = TRUE;
7969     }
7970
7971   gtk_drag_finish (context,
7972                    accepted,
7973                    (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
7974                    time);
7975
7976   if (gtk_tree_path_get_depth (dest_row) == 1 &&
7977       gtk_tree_path_get_indices (dest_row)[0] == 0 &&
7978       gtk_tree_model_iter_n_children (tree_view->priv->model, NULL) != 0)
7979     {
7980       /* special special case drag to "0", scroll to first item */
7981       if (!tree_view->priv->scroll_to_path)
7982         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
7983     }
7984
7985   gtk_tree_path_free (dest_row);
7986
7987   /* drop dest_row */
7988   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
7989 }
7990
7991
7992
7993 /* GtkContainer Methods
7994  */
7995
7996
7997 static void
7998 gtk_tree_view_remove (GtkContainer *container,
7999                       GtkWidget    *widget)
8000 {
8001   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8002   GtkTreeViewChild *child = NULL;
8003   GList *tmp_list;
8004
8005   tmp_list = tree_view->priv->children;
8006   while (tmp_list)
8007     {
8008       child = tmp_list->data;
8009       if (child->widget == widget)
8010         {
8011           gtk_widget_unparent (widget);
8012
8013           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
8014           g_list_free_1 (tmp_list);
8015           g_slice_free (GtkTreeViewChild, child);
8016           return;
8017         }
8018
8019       tmp_list = tmp_list->next;
8020     }
8021
8022   tmp_list = tree_view->priv->columns;
8023
8024   while (tmp_list)
8025     {
8026       GtkTreeViewColumn *column;
8027       GtkWidget         *button;
8028
8029       column = tmp_list->data;
8030       button = gtk_tree_view_column_get_button (column);
8031
8032       if (button == widget)
8033         {
8034           gtk_widget_unparent (widget);
8035           return;
8036         }
8037       tmp_list = tmp_list->next;
8038     }
8039 }
8040
8041 static void
8042 gtk_tree_view_forall (GtkContainer *container,
8043                       gboolean      include_internals,
8044                       GtkCallback   callback,
8045                       gpointer      callback_data)
8046 {
8047   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8048   GtkTreeViewChild *child = NULL;
8049   GtkTreeViewColumn *column;
8050   GtkWidget *button;
8051   GList *tmp_list;
8052
8053   tmp_list = tree_view->priv->children;
8054   while (tmp_list)
8055     {
8056       child = tmp_list->data;
8057       tmp_list = tmp_list->next;
8058
8059       (* callback) (child->widget, callback_data);
8060     }
8061   if (include_internals == FALSE)
8062     return;
8063
8064   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8065     {
8066       column = tmp_list->data;
8067       button = gtk_tree_view_column_get_button (column);
8068
8069       if (button)
8070         (* callback) (button, callback_data);
8071     }
8072 }
8073
8074 /* Returns TRUE is any of the columns contains a cell that can-focus.
8075  * If this is not the case, a column-spanning focus rectangle will be
8076  * drawn.
8077  */
8078 static gboolean
8079 gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view)
8080 {
8081   GList *list;
8082
8083   for (list = tree_view->priv->columns; list; list = list->next)
8084     {
8085       GtkTreeViewColumn *column = list->data;
8086
8087       if (!gtk_tree_view_column_get_visible (column))
8088         continue;
8089       if (gtk_cell_area_is_activatable (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column))))
8090         return TRUE;
8091     }
8092
8093   return FALSE;
8094 }
8095
8096 static void
8097 column_sizing_notify (GObject    *object,
8098                       GParamSpec *pspec,
8099                       gpointer    data)
8100 {
8101   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
8102
8103   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
8104     /* disable fixed height mode */
8105     g_object_set (data, "fixed-height-mode", FALSE, NULL);
8106 }
8107
8108 /**
8109  * gtk_tree_view_set_fixed_height_mode:
8110  * @tree_view: a #GtkTreeView
8111  * @enable: %TRUE to enable fixed height mode
8112  *
8113  * Enables or disables the fixed height mode of @tree_view.
8114  * Fixed height mode speeds up #GtkTreeView by assuming that all
8115  * rows have the same height.
8116  * Only enable this option if all rows are the same height and all
8117  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
8118  *
8119  * Since: 2.6
8120  **/
8121 void
8122 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
8123                                      gboolean     enable)
8124 {
8125   GList *l;
8126
8127   enable = enable != FALSE;
8128
8129   if (enable == tree_view->priv->fixed_height_mode)
8130     return;
8131
8132   if (!enable)
8133     {
8134       tree_view->priv->fixed_height_mode = 0;
8135       tree_view->priv->fixed_height = -1;
8136
8137       /* force a revalidation */
8138       install_presize_handler (tree_view);
8139     }
8140   else
8141     {
8142       /* make sure all columns are of type FIXED */
8143       for (l = tree_view->priv->columns; l; l = l->next)
8144         {
8145           GtkTreeViewColumn *c = l->data;
8146
8147           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
8148         }
8149
8150       /* yes, we really have to do this is in a separate loop */
8151       for (l = tree_view->priv->columns; l; l = l->next)
8152         g_signal_connect (l->data, "notify::sizing",
8153                           G_CALLBACK (column_sizing_notify), tree_view);
8154
8155       tree_view->priv->fixed_height_mode = 1;
8156       tree_view->priv->fixed_height = -1;
8157
8158       if (tree_view->priv->tree)
8159         initialize_fixed_height_mode (tree_view);
8160     }
8161
8162   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
8163 }
8164
8165 /**
8166  * gtk_tree_view_get_fixed_height_mode:
8167  * @tree_view: a #GtkTreeView
8168  *
8169  * Returns whether fixed height mode is turned on for @tree_view.
8170  *
8171  * Return value: %TRUE if @tree_view is in fixed height mode
8172  *
8173  * Since: 2.6
8174  **/
8175 gboolean
8176 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
8177 {
8178   return tree_view->priv->fixed_height_mode;
8179 }
8180
8181 /* Returns TRUE if the focus is within the headers, after the focus operation is
8182  * done
8183  */
8184 static gboolean
8185 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
8186                             GtkDirectionType  dir,
8187                             gboolean          clamp_column_visible)
8188 {
8189   GtkTreeViewColumn *column;
8190   GtkWidget *focus_child;
8191   GtkWidget *button;
8192   GList *last_column, *first_column;
8193   GList *tmp_list;
8194   gboolean rtl;
8195
8196   if (! tree_view->priv->headers_visible)
8197     return FALSE;
8198
8199   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
8200
8201   first_column = tree_view->priv->columns;
8202   while (first_column)
8203     {
8204       column = GTK_TREE_VIEW_COLUMN (first_column->data);
8205       button = gtk_tree_view_column_get_button (column);
8206
8207       if (gtk_widget_get_can_focus (button) &&
8208           gtk_tree_view_column_get_visible (column) &&
8209           (gtk_tree_view_column_get_clickable (column) ||
8210            gtk_tree_view_column_get_reorderable (column)))
8211         break;
8212       first_column = first_column->next;
8213     }
8214
8215   /* No headers are visible, or are focusable.  We can't focus in or out.
8216    */
8217   if (first_column == NULL)
8218     return FALSE;
8219
8220   last_column = g_list_last (tree_view->priv->columns);
8221   while (last_column)
8222     {
8223       column = GTK_TREE_VIEW_COLUMN (last_column->data);
8224       button = gtk_tree_view_column_get_button (column);
8225
8226       if (gtk_widget_get_can_focus (button) &&
8227           gtk_tree_view_column_get_visible (column) &&
8228           (gtk_tree_view_column_get_clickable (column) ||
8229            gtk_tree_view_column_get_reorderable (column)))
8230         break;
8231       last_column = last_column->prev;
8232     }
8233
8234
8235   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8236
8237   switch (dir)
8238     {
8239     case GTK_DIR_TAB_BACKWARD:
8240     case GTK_DIR_TAB_FORWARD:
8241     case GTK_DIR_UP:
8242     case GTK_DIR_DOWN:
8243       if (focus_child == NULL)
8244         {
8245           if (tree_view->priv->focus_column != NULL)
8246             button = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8247           else
8248             button = NULL;
8249
8250           if (button && gtk_widget_get_can_focus (button))
8251             focus_child = button;
8252           else
8253             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8254
8255           gtk_widget_grab_focus (focus_child);
8256           break;
8257         }
8258       return FALSE;
8259
8260     case GTK_DIR_LEFT:
8261     case GTK_DIR_RIGHT:
8262       if (focus_child == NULL)
8263         {
8264           if (tree_view->priv->focus_column != NULL)
8265             focus_child = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8266           else if (dir == GTK_DIR_LEFT)
8267             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (last_column->data));
8268           else
8269             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8270
8271           gtk_widget_grab_focus (focus_child);
8272           break;
8273         }
8274
8275       if (gtk_widget_child_focus (focus_child, dir))
8276         {
8277           /* The focus moves inside the button. */
8278           /* This is probably a great example of bad UI */
8279           break;
8280         }
8281
8282       /* We need to move the focus among the row of buttons. */
8283       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8284         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8285           break;
8286
8287       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
8288           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
8289         {
8290           gtk_widget_error_bell (GTK_WIDGET (tree_view));
8291           break;
8292         }
8293
8294       while (tmp_list)
8295         {
8296           GtkTreeViewColumn *column;
8297           GtkWidget         *button;
8298
8299           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
8300             tmp_list = tmp_list->next;
8301           else
8302             tmp_list = tmp_list->prev;
8303
8304           if (tmp_list == NULL)
8305             {
8306               g_warning ("Internal button not found");
8307               break;
8308             }
8309           column = tmp_list->data;
8310           button = gtk_tree_view_column_get_button (column);
8311           if (button &&
8312               gtk_tree_view_column_get_visible (column) &&
8313               gtk_widget_get_can_focus (button))
8314             {
8315               focus_child = button;
8316               gtk_widget_grab_focus (button);
8317               break;
8318             }
8319         }
8320       break;
8321     default:
8322       g_assert_not_reached ();
8323       break;
8324     }
8325
8326   /* if focus child is non-null, we assume it's been set to the current focus child
8327    */
8328   if (focus_child)
8329     {
8330       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8331         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8332           {
8333             _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (tmp_list->data));
8334             break;
8335           }
8336
8337       if (clamp_column_visible)
8338         {
8339           gtk_tree_view_clamp_column_visible (tree_view,
8340                                               tree_view->priv->focus_column,
8341                                               FALSE);
8342         }
8343     }
8344
8345   return (focus_child != NULL);
8346 }
8347
8348 /* This function returns in 'path' the first focusable path, if the given path
8349  * is already focusable, it's the returned one.
8350  */
8351 static gboolean
8352 search_first_focusable_path (GtkTreeView  *tree_view,
8353                              GtkTreePath **path,
8354                              gboolean      search_forward,
8355                              GtkRBTree   **new_tree,
8356                              GtkRBNode   **new_node)
8357 {
8358   GtkRBTree *tree = NULL;
8359   GtkRBNode *node = NULL;
8360
8361   if (!path || !*path)
8362     return FALSE;
8363
8364   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
8365
8366   if (!tree || !node)
8367     return FALSE;
8368
8369   while (node && row_is_separator (tree_view, NULL, *path))
8370     {
8371       if (search_forward)
8372         _gtk_rbtree_next_full (tree, node, &tree, &node);
8373       else
8374         _gtk_rbtree_prev_full (tree, node, &tree, &node);
8375
8376       if (*path)
8377         gtk_tree_path_free (*path);
8378
8379       if (node)
8380         *path = _gtk_tree_path_new_from_rbtree (tree, node);
8381       else
8382         *path = NULL;
8383     }
8384
8385   if (new_tree)
8386     *new_tree = tree;
8387
8388   if (new_node)
8389     *new_node = node;
8390
8391   return (*path != NULL);
8392 }
8393
8394 static gint
8395 gtk_tree_view_focus (GtkWidget        *widget,
8396                      GtkDirectionType  direction)
8397 {
8398   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8399   GtkContainer *container = GTK_CONTAINER (widget);
8400   GtkWidget *focus_child;
8401
8402   if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
8403     return FALSE;
8404
8405   focus_child = gtk_container_get_focus_child (container);
8406
8407   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
8408   /* Case 1.  Headers currently have focus. */
8409   if (focus_child)
8410     {
8411       switch (direction)
8412         {
8413         case GTK_DIR_LEFT:
8414         case GTK_DIR_RIGHT:
8415           gtk_tree_view_header_focus (tree_view, direction, TRUE);
8416           return TRUE;
8417         case GTK_DIR_TAB_BACKWARD:
8418         case GTK_DIR_UP:
8419           return FALSE;
8420         case GTK_DIR_TAB_FORWARD:
8421         case GTK_DIR_DOWN:
8422           gtk_widget_grab_focus (widget);
8423           return TRUE;
8424         default:
8425           g_assert_not_reached ();
8426           return FALSE;
8427         }
8428     }
8429
8430   /* Case 2. We don't have focus at all. */
8431   if (!gtk_widget_has_focus (widget))
8432     {
8433       gtk_widget_grab_focus (widget);
8434       return TRUE;
8435     }
8436
8437   /* Case 3. We have focus already. */
8438   if (direction == GTK_DIR_TAB_BACKWARD)
8439     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
8440   else if (direction == GTK_DIR_TAB_FORWARD)
8441     return FALSE;
8442
8443   /* Other directions caught by the keybindings */
8444   gtk_widget_grab_focus (widget);
8445   return TRUE;
8446 }
8447
8448 static void
8449 gtk_tree_view_grab_focus (GtkWidget *widget)
8450 {
8451   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
8452
8453   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
8454 }
8455
8456 static void
8457 gtk_tree_view_style_updated (GtkWidget *widget)
8458 {
8459   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8460   GList *list;
8461   GtkTreeViewColumn *column;
8462
8463   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->style_updated (widget);
8464
8465   if (gtk_widget_get_realized (widget))
8466     {
8467       gtk_tree_view_ensure_background (tree_view);
8468
8469       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
8470       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
8471     }
8472
8473   for (list = tree_view->priv->columns; list; list = list->next)
8474     {
8475       column = list->data;
8476       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8477     }
8478
8479   tree_view->priv->fixed_height = -1;
8480   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
8481
8482   gtk_widget_queue_resize (widget);
8483 }
8484
8485
8486 static void
8487 gtk_tree_view_set_focus_child (GtkContainer *container,
8488                                GtkWidget    *child)
8489 {
8490   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8491   GList *list;
8492
8493   for (list = tree_view->priv->columns; list; list = list->next)
8494     {
8495       if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child)
8496         {
8497           _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
8498           break;
8499         }
8500     }
8501
8502   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
8503 }
8504
8505 static GtkWidgetPath *
8506 gtk_tree_view_get_path_for_child (GtkContainer *container,
8507                                   GtkWidget    *child)
8508 {
8509   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8510   GtkWidgetPath *path;
8511   gboolean rtl;
8512   GList *list, *visible_columns = NULL;
8513   gint n_col = 0;
8514
8515   path = GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->get_path_for_child (container, child);
8516   rtl = (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL);
8517
8518   for (list = tree_view->priv->columns; list; list = list->next)
8519     {
8520       GtkTreeViewColumn *column = list->data;
8521
8522       if (gtk_tree_view_column_get_visible (column))
8523         visible_columns = g_list_prepend (visible_columns, column);
8524     }
8525
8526   if (!rtl)
8527     visible_columns = g_list_reverse (visible_columns);
8528
8529   for (list = visible_columns; list != NULL; list = list->next)
8530     {
8531       GtkTreeViewColumn *column = list->data;
8532       GtkRegionFlags flags = 0;
8533
8534       n_col++;
8535
8536       if (gtk_tree_view_column_get_widget (column) != child &&
8537           gtk_tree_view_column_get_button (column) != child)
8538         continue;
8539
8540       if ((n_col % 2) == 0)
8541         flags |= GTK_REGION_EVEN;
8542       else
8543         flags |= GTK_REGION_ODD;
8544
8545       if (n_col == 1)
8546         flags |= GTK_REGION_FIRST;
8547
8548       if (!list->next)
8549         flags |= GTK_REGION_LAST;
8550
8551       gtk_widget_path_iter_add_region (path, -1, GTK_STYLE_REGION_COLUMN_HEADER, flags);
8552       break;
8553     }
8554   g_list_free (visible_columns);
8555
8556   gtk_widget_path_append_for_widget (path, child);
8557
8558   return path;
8559 }
8560
8561 static gboolean
8562 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8563                                 GtkMovementStep    step,
8564                                 gint               count)
8565 {
8566   GdkModifierType state;
8567
8568   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8569   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8570                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8571                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8572                         step == GTK_MOVEMENT_PAGES ||
8573                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8574
8575   if (tree_view->priv->tree == NULL)
8576     return FALSE;
8577   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8578     return FALSE;
8579
8580   gtk_tree_view_stop_editing (tree_view, FALSE);
8581   tree_view->priv->draw_keyfocus = TRUE;
8582   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8583
8584   if (gtk_get_current_event_state (&state))
8585     {
8586       GdkModifierType extend_mod_mask;
8587       GdkModifierType modify_mod_mask;
8588
8589       extend_mod_mask =
8590         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8591                                       GDK_MODIFIER_INTENT_EXTEND_SELECTION);
8592
8593       modify_mod_mask =
8594         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8595                                       GDK_MODIFIER_INTENT_MODIFY_SELECTION);
8596
8597       if ((state & modify_mod_mask) == modify_mod_mask)
8598         tree_view->priv->modify_selection_pressed = TRUE;
8599       if ((state & extend_mod_mask) == extend_mod_mask)
8600         tree_view->priv->extend_selection_pressed = TRUE;
8601     }
8602   /* else we assume not pressed */
8603
8604   switch (step)
8605     {
8606       /* currently we make no distinction.  When we go bi-di, we need to */
8607     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8608     case GTK_MOVEMENT_VISUAL_POSITIONS:
8609       gtk_tree_view_move_cursor_left_right (tree_view, count);
8610       break;
8611     case GTK_MOVEMENT_DISPLAY_LINES:
8612       gtk_tree_view_move_cursor_up_down (tree_view, count);
8613       break;
8614     case GTK_MOVEMENT_PAGES:
8615       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8616       break;
8617     case GTK_MOVEMENT_BUFFER_ENDS:
8618       gtk_tree_view_move_cursor_start_end (tree_view, count);
8619       break;
8620     default:
8621       g_assert_not_reached ();
8622     }
8623
8624   tree_view->priv->modify_selection_pressed = FALSE;
8625   tree_view->priv->extend_selection_pressed = FALSE;
8626
8627   return TRUE;
8628 }
8629
8630 static void
8631 gtk_tree_view_put (GtkTreeView *tree_view,
8632                    GtkWidget   *child_widget,
8633                    /* in bin_window coordinates */
8634                    gint         x,
8635                    gint         y,
8636                    gint         width,
8637                    gint         height)
8638 {
8639   GtkTreeViewChild *child;
8640
8641   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8642   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8643
8644   child = g_slice_new (GtkTreeViewChild);
8645
8646   child->widget = child_widget;
8647   child->x = x;
8648   child->y = y;
8649   child->width = width;
8650   child->height = height;
8651
8652   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8653
8654   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8655     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8656
8657   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8658 }
8659
8660 void
8661 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8662                                   GtkWidget   *widget,
8663                                   /* in tree coordinates */
8664                                   gint         x,
8665                                   gint         y,
8666                                   gint         width,
8667                                   gint         height)
8668 {
8669   GtkTreeViewChild *child = NULL;
8670   GList *list;
8671   GdkRectangle allocation;
8672
8673   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8674   g_return_if_fail (GTK_IS_WIDGET (widget));
8675
8676   for (list = tree_view->priv->children; list; list = list->next)
8677     {
8678       if (((GtkTreeViewChild *)list->data)->widget == widget)
8679         {
8680           child = list->data;
8681           break;
8682         }
8683     }
8684   if (child == NULL)
8685     return;
8686
8687   allocation.x = child->x = x;
8688   allocation.y = child->y = y;
8689   allocation.width = child->width = width;
8690   allocation.height = child->height = height;
8691
8692   if (gtk_widget_get_realized (widget))
8693     gtk_widget_size_allocate (widget, &allocation);
8694 }
8695
8696
8697 /* TreeModel Callbacks
8698  */
8699
8700 static void
8701 gtk_tree_view_row_changed (GtkTreeModel *model,
8702                            GtkTreePath  *path,
8703                            GtkTreeIter  *iter,
8704                            gpointer      data)
8705 {
8706   GtkTreeView *tree_view = (GtkTreeView *)data;
8707   GtkRBTree *tree;
8708   GtkRBNode *node;
8709   gboolean free_path = FALSE;
8710   GList *list;
8711   GtkTreePath *cursor_path;
8712
8713   g_return_if_fail (path != NULL || iter != NULL);
8714
8715   if (tree_view->priv->cursor_node != NULL)
8716     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
8717                                                   tree_view->priv->cursor_node);
8718   else
8719     cursor_path = NULL;
8720
8721   if (tree_view->priv->edited_column &&
8722       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8723     gtk_tree_view_stop_editing (tree_view, TRUE);
8724
8725   if (cursor_path != NULL)
8726     gtk_tree_path_free (cursor_path);
8727
8728   if (path == NULL)
8729     {
8730       path = gtk_tree_model_get_path (model, iter);
8731       free_path = TRUE;
8732     }
8733   else if (iter == NULL)
8734     gtk_tree_model_get_iter (model, iter, path);
8735
8736   if (_gtk_tree_view_find_node (tree_view,
8737                                 path,
8738                                 &tree,
8739                                 &node))
8740     /* We aren't actually showing the node */
8741     goto done;
8742
8743   if (tree == NULL)
8744     goto done;
8745
8746   _gtk_tree_view_accessible_changed (tree_view, tree, node);
8747
8748   if (tree_view->priv->fixed_height_mode
8749       && tree_view->priv->fixed_height >= 0)
8750     {
8751       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8752       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8753         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8754     }
8755   else
8756     {
8757       _gtk_rbtree_node_mark_invalid (tree, node);
8758       for (list = tree_view->priv->columns; list; list = list->next)
8759         {
8760           GtkTreeViewColumn *column;
8761
8762           column = list->data;
8763           if (!gtk_tree_view_column_get_visible (column))
8764             continue;
8765
8766           if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8767             {
8768               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8769             }
8770         }
8771     }
8772
8773  done:
8774   if (!tree_view->priv->fixed_height_mode &&
8775       gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8776     install_presize_handler (tree_view);
8777   if (free_path)
8778     gtk_tree_path_free (path);
8779 }
8780
8781 static void
8782 gtk_tree_view_row_inserted (GtkTreeModel *model,
8783                             GtkTreePath  *path,
8784                             GtkTreeIter  *iter,
8785                             gpointer      data)
8786 {
8787   GtkTreeView *tree_view = (GtkTreeView *) data;
8788   gint *indices;
8789   GtkRBTree *tree;
8790   GtkRBNode *tmpnode = NULL;
8791   gint depth;
8792   gint i = 0;
8793   gint height;
8794   gboolean free_path = FALSE;
8795   gboolean node_visible = TRUE;
8796
8797   g_return_if_fail (path != NULL || iter != NULL);
8798
8799   if (tree_view->priv->fixed_height_mode
8800       && tree_view->priv->fixed_height >= 0)
8801     height = tree_view->priv->fixed_height;
8802   else
8803     height = 0;
8804
8805   if (path == NULL)
8806     {
8807       path = gtk_tree_model_get_path (model, iter);
8808       free_path = TRUE;
8809     }
8810   else if (iter == NULL)
8811     gtk_tree_model_get_iter (model, iter, path);
8812
8813   if (tree_view->priv->tree == NULL)
8814     tree_view->priv->tree = _gtk_rbtree_new ();
8815
8816   tree = tree_view->priv->tree;
8817
8818   /* Update all row-references */
8819   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8820   depth = gtk_tree_path_get_depth (path);
8821   indices = gtk_tree_path_get_indices (path);
8822
8823   /* First, find the parent tree */
8824   while (i < depth - 1)
8825     {
8826       if (tree == NULL)
8827         {
8828           /* We aren't showing the node */
8829           node_visible = FALSE;
8830           goto done;
8831         }
8832
8833       tmpnode = _gtk_rbtree_find_count (tree, indices[i] + 1);
8834       if (tmpnode == NULL)
8835         {
8836           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8837                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8838                      "before the parent was inserted.");
8839           goto done;
8840         }
8841       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8842         {
8843           /* FIXME enforce correct behavior on model, probably */
8844           /* In theory, the model should have emitted has_child_toggled here.  We
8845            * try to catch it anyway, just to be safe, in case the model hasn't.
8846            */
8847           GtkTreePath *tmppath = _gtk_tree_path_new_from_rbtree (tree, tmpnode);
8848           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8849           gtk_tree_path_free (tmppath);
8850           goto done;
8851         }
8852
8853       tree = tmpnode->children;
8854       i++;
8855     }
8856
8857   if (tree == NULL)
8858     {
8859       node_visible = FALSE;
8860       goto done;
8861     }
8862
8863   /* ref the node */
8864   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8865   if (indices[depth - 1] == 0)
8866     {
8867       tmpnode = _gtk_rbtree_find_count (tree, 1);
8868       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8869     }
8870   else
8871     {
8872       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8873       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8874     }
8875
8876   _gtk_tree_view_accessible_add (tree_view, tree, tmpnode);
8877
8878  done:
8879   if (height > 0)
8880     {
8881       if (tree)
8882         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8883
8884       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8885         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8886       else
8887         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8888     }
8889   else
8890     install_presize_handler (tree_view);
8891   if (free_path)
8892     gtk_tree_path_free (path);
8893 }
8894
8895 static void
8896 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8897                                      GtkTreePath  *path,
8898                                      GtkTreeIter  *iter,
8899                                      gpointer      data)
8900 {
8901   GtkTreeView *tree_view = (GtkTreeView *)data;
8902   GtkTreeIter real_iter;
8903   gboolean has_child;
8904   GtkRBTree *tree;
8905   GtkRBNode *node;
8906   gboolean free_path = FALSE;
8907
8908   g_return_if_fail (path != NULL || iter != NULL);
8909
8910   if (iter)
8911     real_iter = *iter;
8912
8913   if (path == NULL)
8914     {
8915       path = gtk_tree_model_get_path (model, iter);
8916       free_path = TRUE;
8917     }
8918   else if (iter == NULL)
8919     gtk_tree_model_get_iter (model, &real_iter, path);
8920
8921   if (_gtk_tree_view_find_node (tree_view,
8922                                 path,
8923                                 &tree,
8924                                 &node))
8925     /* We aren't actually showing the node */
8926     goto done;
8927
8928   if (tree == NULL)
8929     goto done;
8930
8931   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8932   /* Sanity check.
8933    */
8934   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8935     goto done;
8936
8937   if (has_child)
8938     {
8939       GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8940       _gtk_tree_view_accessible_add_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8941     }
8942   else
8943     {
8944       GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8945       _gtk_tree_view_accessible_remove_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8946     }
8947
8948   if (has_child && tree_view->priv->is_list)
8949     {
8950       tree_view->priv->is_list = FALSE;
8951       if (tree_view->priv->show_expanders)
8952         {
8953           GList *list;
8954
8955           for (list = tree_view->priv->columns; list; list = list->next)
8956             if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
8957               {
8958                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8959                 break;
8960               }
8961         }
8962       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8963     }
8964   else
8965     {
8966       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8967     }
8968
8969  done:
8970   if (free_path)
8971     gtk_tree_path_free (path);
8972 }
8973
8974 static void
8975 count_children_helper (GtkRBTree *tree,
8976                        GtkRBNode *node,
8977                        gpointer   data)
8978 {
8979   if (node->children)
8980     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8981   (*((gint *)data))++;
8982 }
8983
8984 static void
8985 check_selection_helper (GtkRBTree *tree,
8986                         GtkRBNode *node,
8987                         gpointer   data)
8988 {
8989   gint *value = (gint *)data;
8990
8991   *value |= GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8992
8993   if (node->children && !*value)
8994     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8995 }
8996
8997 static void
8998 gtk_tree_view_row_deleted (GtkTreeModel *model,
8999                            GtkTreePath  *path,
9000                            gpointer      data)
9001 {
9002   GtkTreeView *tree_view = (GtkTreeView *)data;
9003   GtkRBTree *tree;
9004   GtkRBNode *node;
9005   GList *list;
9006   gboolean selection_changed = FALSE, cursor_changed = FALSE;
9007   GtkRBTree *cursor_tree = NULL;
9008   GtkRBNode *cursor_node = NULL;
9009
9010   g_return_if_fail (path != NULL);
9011
9012   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
9013
9014   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
9015     return;
9016
9017   if (tree == NULL)
9018     return;
9019
9020   /* check if the selection has been changed */
9021   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
9022                         check_selection_helper, &selection_changed);
9023
9024   for (list = tree_view->priv->columns; list; list = list->next)
9025     if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)) &&
9026         gtk_tree_view_column_get_sizing (GTK_TREE_VIEW_COLUMN (list->data)) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9027       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
9028
9029   /* Ensure we don't have a dangling pointer to a dead node */
9030   ensure_unprelighted (tree_view);
9031
9032   /* Cancel editting if we've started */
9033   gtk_tree_view_stop_editing (tree_view, TRUE);
9034
9035   /* If the cursor row got deleted, move the cursor to the next row */
9036   if (tree_view->priv->cursor_node &&
9037       (tree_view->priv->cursor_node == node ||
9038        (node->children && (tree_view->priv->cursor_tree == node->children ||
9039                            _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree)))))
9040     {
9041       GtkTreePath *cursor_path;
9042
9043       cursor_tree = tree;
9044       cursor_node = _gtk_rbtree_next (tree, node);
9045       /* find the first node that is not going to be deleted */
9046       while (cursor_node == NULL && cursor_tree->parent_tree)
9047         {
9048           cursor_node = _gtk_rbtree_next (cursor_tree->parent_tree,
9049                                           cursor_tree->parent_node);
9050           cursor_tree = cursor_tree->parent_tree;
9051         }
9052
9053       if (cursor_node != NULL)
9054         cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9055       else
9056         cursor_path = NULL;
9057
9058       if (cursor_path == NULL ||
9059           ! search_first_focusable_path (tree_view, &cursor_path, TRUE,
9060                                          &cursor_tree, &cursor_node))
9061         {
9062           /* It looks like we reached the end of the view without finding
9063            * a focusable row.  We will step backwards to find the last
9064            * focusable row.
9065            */
9066           _gtk_rbtree_prev_full (tree, node, &cursor_tree, &cursor_node);
9067           if (cursor_node)
9068             {
9069               cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9070               if (! search_first_focusable_path (tree_view, &cursor_path, FALSE,
9071                                                  &cursor_tree, &cursor_node))
9072                 cursor_node = NULL;
9073               gtk_tree_path_free (cursor_path);
9074             }
9075         }
9076       else if (cursor_path)
9077         gtk_tree_path_free (cursor_path);
9078
9079       cursor_changed = TRUE;
9080     }
9081
9082   if (tree_view->priv->destroy_count_func)
9083     {
9084       gint child_count = 0;
9085       if (node->children)
9086         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
9087       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
9088     }
9089
9090   if (tree->root->count == 1)
9091     {
9092       if (tree_view->priv->tree == tree)
9093         tree_view->priv->tree = NULL;
9094
9095       _gtk_tree_view_accessible_remove_state (tree_view,
9096                                               tree->parent_tree, tree->parent_node,
9097                                               GTK_CELL_RENDERER_EXPANDED);
9098       _gtk_tree_view_accessible_remove (tree_view, tree, NULL);
9099       _gtk_rbtree_remove (tree);
9100     }
9101   else
9102     {
9103       _gtk_tree_view_accessible_remove (tree_view, tree, node);
9104       _gtk_rbtree_remove_node (tree, node);
9105     }
9106
9107   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
9108     {
9109       gtk_tree_row_reference_free (tree_view->priv->top_row);
9110       tree_view->priv->top_row = NULL;
9111     }
9112
9113   install_scroll_sync_handler (tree_view);
9114
9115   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9116
9117   if (cursor_changed)
9118     {
9119       if (cursor_node)
9120         {
9121           GtkTreePath *cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9122           gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CURSOR_INVALID);
9123           gtk_tree_path_free (cursor_path);
9124         }
9125       else
9126         gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT | CURSOR_INVALID);
9127     }
9128   if (selection_changed)
9129     g_signal_emit_by_name (tree_view->priv->selection, "changed");
9130 }
9131
9132 static void
9133 gtk_tree_view_rows_reordered (GtkTreeModel *model,
9134                               GtkTreePath  *parent,
9135                               GtkTreeIter  *iter,
9136                               gint         *new_order,
9137                               gpointer      data)
9138 {
9139   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
9140   GtkRBTree *tree;
9141   GtkRBNode *node;
9142   gint len;
9143
9144   len = gtk_tree_model_iter_n_children (model, iter);
9145
9146   if (len < 2)
9147     return;
9148
9149   gtk_tree_row_reference_reordered (G_OBJECT (data),
9150                                     parent,
9151                                     iter,
9152                                     new_order);
9153
9154   if (_gtk_tree_view_find_node (tree_view,
9155                                 parent,
9156                                 &tree,
9157                                 &node))
9158     return;
9159
9160   /* We need to special case the parent path */
9161   if (tree == NULL)
9162     tree = tree_view->priv->tree;
9163   else
9164     tree = node->children;
9165
9166   if (tree == NULL)
9167     return;
9168
9169   if (tree_view->priv->edited_column)
9170     gtk_tree_view_stop_editing (tree_view, TRUE);
9171
9172   /* we need to be unprelighted */
9173   ensure_unprelighted (tree_view);
9174
9175   _gtk_rbtree_reorder (tree, new_order, len);
9176
9177   _gtk_tree_view_accessible_reorder (tree_view);
9178
9179   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
9180
9181   gtk_tree_view_dy_to_top_row (tree_view);
9182 }
9183
9184
9185 /* Internal tree functions
9186  */
9187
9188
9189 static void
9190 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
9191                                      GtkRBTree         *tree,
9192                                      GtkTreeViewColumn *column,
9193                                      gint              *x1,
9194                                      gint              *x2)
9195 {
9196   GtkTreeViewColumn *tmp_column = NULL;
9197   gint total_width;
9198   GList *list;
9199   gboolean rtl;
9200
9201   if (x1)
9202     *x1 = 0;
9203
9204   if (x2)
9205     *x2 = 0;
9206
9207   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9208
9209   total_width = 0;
9210   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9211        list;
9212        list = (rtl ? list->prev : list->next))
9213     {
9214       tmp_column = list->data;
9215
9216       if (tmp_column == column)
9217         break;
9218
9219       if (gtk_tree_view_column_get_visible (tmp_column))
9220         total_width += gtk_tree_view_column_get_width (tmp_column);
9221     }
9222
9223   if (tmp_column != column)
9224     {
9225       g_warning (G_STRLOC": passed-in column isn't in the tree");
9226       return;
9227     }
9228
9229   if (x1)
9230     *x1 = total_width;
9231
9232   if (x2)
9233     {
9234       if (gtk_tree_view_column_get_visible (column))
9235         *x2 = total_width + gtk_tree_view_column_get_width (column);
9236       else
9237         *x2 = total_width; /* width of 0 */
9238     }
9239 }
9240
9241 static void
9242 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
9243                                 GtkRBTree   *tree,
9244                                 gint        *x1,
9245                                 gint        *x2)
9246 {
9247   gint x_offset = 0;
9248   GList *list;
9249   GtkTreeViewColumn *tmp_column = NULL;
9250   gint total_width;
9251   gint expander_size;
9252   gboolean indent_expanders;
9253   gboolean rtl;
9254
9255   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9256   expander_size = gtk_tree_view_get_expander_size (tree_view);
9257
9258   total_width = 0;
9259   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9260        list;
9261        list = (rtl ? list->prev : list->next))
9262     {
9263       tmp_column = list->data;
9264
9265       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
9266         {
9267           if (rtl)
9268             x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - expander_size;
9269           else
9270             x_offset = total_width;
9271           break;
9272         }
9273
9274       if (gtk_tree_view_column_get_visible (tmp_column))
9275         total_width += gtk_tree_view_column_get_width (tmp_column);
9276     }
9277
9278   gtk_widget_style_get (GTK_WIDGET (tree_view),
9279                         "indent-expanders", &indent_expanders,
9280                         NULL);
9281
9282   if (indent_expanders)
9283     {
9284       if (rtl)
9285         x_offset -= expander_size * _gtk_rbtree_get_depth (tree);
9286       else
9287         x_offset += expander_size * _gtk_rbtree_get_depth (tree);
9288     }
9289
9290   *x1 = x_offset;
9291
9292   if (tmp_column &&
9293       gtk_tree_view_column_get_visible (tmp_column))
9294     /* +1 because x2 isn't included in the range. */
9295     *x2 = *x1 + expander_size + 1;
9296   else
9297     *x2 = *x1;
9298 }
9299
9300 static void
9301 gtk_tree_view_build_tree (GtkTreeView *tree_view,
9302                           GtkRBTree   *tree,
9303                           GtkTreeIter *iter,
9304                           gint         depth,
9305                           gboolean     recurse)
9306 {
9307   GtkRBNode *temp = NULL;
9308   GtkTreePath *path = NULL;
9309
9310   do
9311     {
9312       gtk_tree_model_ref_node (tree_view->priv->model, iter);
9313       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
9314
9315       if (tree_view->priv->fixed_height > 0)
9316         {
9317           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
9318             {
9319               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
9320               _gtk_rbtree_node_mark_valid (tree, temp);
9321             }
9322         }
9323
9324       if (tree_view->priv->is_list)
9325         continue;
9326
9327       if (recurse)
9328         {
9329           GtkTreeIter child;
9330
9331           if (!path)
9332             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
9333           else
9334             gtk_tree_path_next (path);
9335
9336           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
9337             {
9338               gboolean expand;
9339
9340               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
9341
9342               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
9343                   && !expand)
9344                 {
9345                   temp->children = _gtk_rbtree_new ();
9346                   temp->children->parent_tree = tree;
9347                   temp->children->parent_node = temp;
9348                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
9349                 }
9350             }
9351         }
9352
9353       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
9354         {
9355           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
9356             temp->flags ^= GTK_RBNODE_IS_PARENT;
9357         }
9358     }
9359   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
9360
9361   if (path)
9362     gtk_tree_path_free (path);
9363 }
9364
9365 /* Make sure the node is visible vertically */
9366 static void
9367 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
9368                                   GtkRBTree   *tree,
9369                                   GtkRBNode   *node)
9370 {
9371   gint node_dy, height;
9372   GtkTreePath *path = NULL;
9373
9374   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9375     return;
9376
9377   /* just return if the node is visible, avoiding a costly expose */
9378   node_dy = _gtk_rbtree_node_find_offset (tree, node);
9379   height = gtk_tree_view_get_row_height (tree_view, node);
9380   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
9381       && node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment)
9382       && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
9383                               + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
9384     return;
9385
9386   path = _gtk_tree_path_new_from_rbtree (tree, node);
9387   if (path)
9388     {
9389       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
9390       gtk_tree_path_free (path);
9391     }
9392 }
9393
9394 static void
9395 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
9396                                     GtkTreeViewColumn *column,
9397                                     gboolean           focus_to_cell)
9398 {
9399   GtkAllocation allocation;
9400   gint x, width;
9401
9402   if (column == NULL)
9403     return;
9404
9405   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
9406   x = allocation.x;
9407   width = allocation.width;
9408
9409   if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9410     {
9411       /* The column is larger than the horizontal page size.  If the
9412        * column has cells which can be focussed individually, then we make
9413        * sure the cell which gets focus is fully visible (if even the
9414        * focus cell is bigger than the page size, we make sure the
9415        * left-hand side of the cell is visible).
9416        *
9417        * If the column does not have an activatable cell, we
9418        * make sure the left-hand side of the column is visible.
9419        */
9420
9421       if (focus_to_cell && gtk_tree_view_has_can_focus_cell (tree_view))
9422         {
9423           GtkCellArea *cell_area;
9424           GtkCellRenderer *focus_cell;
9425
9426           cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
9427           focus_cell = gtk_cell_area_get_focus_cell (cell_area);
9428
9429           if (gtk_tree_view_column_cell_get_position (column, focus_cell,
9430                                                       &x, &width))
9431             {
9432               if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9433                 {
9434                   if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment) < x + width)
9435                     gtk_adjustment_set_value (tree_view->priv->hadjustment,
9436                                               x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9437                   else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9438                     gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9439                 }
9440             }
9441         }
9442
9443       gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9444     }
9445   else
9446     {
9447       if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
9448           gtk_adjustment_set_value (tree_view->priv->hadjustment,
9449                                     x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9450       else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9451         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9452   }
9453 }
9454
9455 /* This function could be more efficient.  I'll optimize it if profiling seems
9456  * to imply that it is important */
9457 GtkTreePath *
9458 _gtk_tree_path_new_from_rbtree (GtkRBTree   *tree,
9459                                 GtkRBNode   *node)
9460 {
9461   GtkTreePath *path;
9462   GtkRBTree *tmp_tree;
9463   GtkRBNode *tmp_node, *last;
9464   gint count;
9465
9466   path = gtk_tree_path_new ();
9467
9468   g_return_val_if_fail (node != NULL, path);
9469
9470   count = 1 + node->left->count;
9471
9472   last = node;
9473   tmp_node = node->parent;
9474   tmp_tree = tree;
9475   while (tmp_tree)
9476     {
9477       while (!_gtk_rbtree_is_nil (tmp_node))
9478         {
9479           if (tmp_node->right == last)
9480             count += 1 + tmp_node->left->count;
9481           last = tmp_node;
9482           tmp_node = tmp_node->parent;
9483         }
9484       gtk_tree_path_prepend_index (path, count - 1);
9485       last = tmp_tree->parent_node;
9486       tmp_tree = tmp_tree->parent_tree;
9487       if (last)
9488         {
9489           count = 1 + last->left->count;
9490           tmp_node = last->parent;
9491         }
9492     }
9493   return path;
9494 }
9495
9496 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
9497  * invalid (ie. points to a node that's not in the tree), *tree and *node are
9498  * both set to NULL.
9499  */
9500 gboolean
9501 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
9502                           GtkTreePath  *path,
9503                           GtkRBTree   **tree,
9504                           GtkRBNode   **node)
9505 {
9506   GtkRBNode *tmpnode = NULL;
9507   GtkRBTree *tmptree = tree_view->priv->tree;
9508   gint *indices = gtk_tree_path_get_indices (path);
9509   gint depth = gtk_tree_path_get_depth (path);
9510   gint i = 0;
9511
9512   *node = NULL;
9513   *tree = NULL;
9514
9515   if (depth == 0 || tmptree == NULL)
9516     return FALSE;
9517   do
9518     {
9519       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
9520       ++i;
9521       if (tmpnode == NULL)
9522         {
9523           *tree = NULL;
9524           *node = NULL;
9525           return FALSE;
9526         }
9527       if (i >= depth)
9528         {
9529           *tree = tmptree;
9530           *node = tmpnode;
9531           return FALSE;
9532         }
9533       *tree = tmptree;
9534       *node = tmpnode;
9535       tmptree = tmpnode->children;
9536       if (tmptree == NULL)
9537         return TRUE;
9538     }
9539   while (1);
9540 }
9541
9542 static gboolean
9543 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9544                                   GtkTreeViewColumn *column)
9545 {
9546   GList *list;
9547
9548   if (tree_view->priv->is_list)
9549     return FALSE;
9550
9551   if (tree_view->priv->expander_column != NULL)
9552     {
9553       if (tree_view->priv->expander_column == column)
9554         return TRUE;
9555       return FALSE;
9556     }
9557   else
9558     {
9559       for (list = tree_view->priv->columns;
9560            list;
9561            list = list->next)
9562         if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
9563           break;
9564       if (list && list->data == column)
9565         return TRUE;
9566     }
9567   return FALSE;
9568 }
9569
9570 static inline gboolean
9571 gtk_tree_view_draw_expanders (GtkTreeView *tree_view)
9572 {
9573   if (!tree_view->priv->is_list && tree_view->priv->show_expanders)
9574     return TRUE;
9575   /* else */
9576   return FALSE;
9577 }
9578
9579 static void
9580 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9581                                 guint           keyval,
9582                                 guint           modmask,
9583                                 gboolean        add_shifted_binding,
9584                                 GtkMovementStep step,
9585                                 gint            count)
9586 {
9587
9588   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9589                                 "move-cursor", 2,
9590                                 G_TYPE_ENUM, step,
9591                                 G_TYPE_INT, count);
9592
9593   if (add_shifted_binding)
9594     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9595                                   "move-cursor", 2,
9596                                   G_TYPE_ENUM, step,
9597                                   G_TYPE_INT, count);
9598
9599   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9600    return;
9601
9602   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9603                                 "move-cursor", 2,
9604                                 G_TYPE_ENUM, step,
9605                                 G_TYPE_INT, count);
9606
9607   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9608                                 "move-cursor", 2,
9609                                 G_TYPE_ENUM, step,
9610                                 G_TYPE_INT, count);
9611 }
9612
9613 static gint
9614 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9615                                  GtkTreeIter  *iter,
9616                                  GtkRBTree    *tree,
9617                                  GtkRBNode    *node)
9618 {
9619   gint retval = FALSE;
9620   do
9621     {
9622       g_return_val_if_fail (node != NULL, FALSE);
9623
9624       if (node->children)
9625         {
9626           GtkTreeIter child;
9627           GtkRBTree *new_tree;
9628           GtkRBNode *new_node;
9629
9630           new_tree = node->children;
9631           new_node = _gtk_rbtree_first (new_tree);
9632
9633           if (!gtk_tree_model_iter_children (model, &child, iter))
9634             return FALSE;
9635
9636           retval = gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node) | retval;
9637         }
9638
9639       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9640         retval = TRUE;
9641       gtk_tree_model_unref_node (model, iter);
9642       node = _gtk_rbtree_next (tree, node);
9643     }
9644   while (gtk_tree_model_iter_next (model, iter));
9645
9646   return retval;
9647 }
9648
9649 static gint
9650 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9651                                               GtkRBTree   *tree)
9652 {
9653   GtkTreeIter iter;
9654   GtkTreePath *path;
9655   GtkRBNode *node;
9656   gint retval;
9657
9658   if (!tree)
9659     return FALSE;
9660
9661   node = _gtk_rbtree_first (tree);
9662
9663   g_return_val_if_fail (node != NULL, FALSE);
9664   path = _gtk_tree_path_new_from_rbtree (tree, node);
9665   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9666                            &iter, path);
9667   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9668   gtk_tree_path_free (path);
9669
9670   return retval;
9671 }
9672
9673 static void
9674 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9675                                     GtkTreeViewColumn *column)
9676 {
9677   GtkTreeViewColumn *left_column;
9678   GtkTreeViewColumn *cur_column = NULL;
9679   GtkTreeViewColumnReorder *reorder;
9680   gboolean rtl;
9681   GList *tmp_list;
9682   gint left;
9683
9684   /* We want to precalculate the motion list such that we know what column slots
9685    * are available.
9686    */
9687   left_column = NULL;
9688   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9689
9690   /* First, identify all possible drop spots */
9691   if (rtl)
9692     tmp_list = g_list_last (tree_view->priv->columns);
9693   else
9694     tmp_list = g_list_first (tree_view->priv->columns);
9695
9696   while (tmp_list)
9697     {
9698       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9699       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9700
9701       if (gtk_tree_view_column_get_visible (cur_column) == FALSE)
9702         continue;
9703
9704       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9705       if (left_column != column && cur_column != column &&
9706           tree_view->priv->column_drop_func &&
9707           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9708         {
9709           left_column = cur_column;
9710           continue;
9711         }
9712       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9713       reorder->left_column = left_column;
9714       left_column = reorder->right_column = cur_column;
9715
9716       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9717     }
9718
9719   /* Add the last one */
9720   if (tree_view->priv->column_drop_func == NULL ||
9721       ((left_column != column) &&
9722        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9723     {
9724       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9725       reorder->left_column = left_column;
9726       reorder->right_column = NULL;
9727       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9728     }
9729
9730   /* We quickly check to see if it even makes sense to reorder columns. */
9731   /* If there is nothing that can be moved, then we return */
9732
9733   if (tree_view->priv->column_drag_info == NULL)
9734     return;
9735
9736   /* We know there are always 2 slots possbile, as you can always return column. */
9737   /* If that's all there is, return */
9738   if (tree_view->priv->column_drag_info->next == NULL ||
9739       (tree_view->priv->column_drag_info->next->next == NULL &&
9740        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9741        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9742     {
9743       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9744         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9745       g_list_free (tree_view->priv->column_drag_info);
9746       tree_view->priv->column_drag_info = NULL;
9747       return;
9748     }
9749   /* We fill in the ranges for the columns, now that we've isolated them */
9750   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9751
9752   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9753     {
9754       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9755
9756       reorder->left_align = left;
9757       if (tmp_list->next != NULL)
9758         {
9759           GtkAllocation right_allocation, left_allocation;
9760           GtkWidget    *left_button, *right_button;
9761
9762           g_assert (tmp_list->next->data);
9763
9764           right_button = gtk_tree_view_column_get_button (reorder->right_column);
9765           left_button  = gtk_tree_view_column_get_button
9766             (((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column);
9767
9768           gtk_widget_get_allocation (right_button, &right_allocation);
9769           gtk_widget_get_allocation (left_button, &left_allocation);
9770           left = reorder->right_align = (right_allocation.x + right_allocation.width + left_allocation.x) / 2;
9771         }
9772       else
9773         {
9774           reorder->right_align = gdk_window_get_width (tree_view->priv->header_window)
9775                                  + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9776         }
9777     }
9778 }
9779
9780 void
9781 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9782                                   GtkTreeViewColumn *column,
9783                                   GdkDevice         *device)
9784 {
9785   GdkEvent *send_event;
9786   GtkAllocation allocation;
9787   GtkAllocation button_allocation;
9788   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9789   GtkWidget *button;
9790   GdkDevice *pointer, *keyboard;
9791   GdkWindowAttr attributes;
9792   guint attributes_mask;
9793
9794   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9795   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9796   g_return_if_fail (tree_view->priv->drag_window == NULL);
9797
9798   gtk_tree_view_set_column_drag_info (tree_view, column);
9799
9800   if (tree_view->priv->column_drag_info == NULL)
9801     return;
9802
9803   button = gtk_tree_view_column_get_button (column);
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   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
9823     {
9824       keyboard = device;
9825       pointer = gdk_device_get_associated_device (device);
9826     }
9827   else
9828     {
9829       pointer = device;
9830       keyboard = gdk_device_get_associated_device (device);
9831     }
9832
9833   gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
9834   gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);
9835
9836   gtk_grab_remove (button);
9837
9838   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9839   send_event->crossing.send_event = TRUE;
9840   send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (button)));
9841   send_event->crossing.subwindow = NULL;
9842   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9843   send_event->crossing.time = GDK_CURRENT_TIME;
9844   gdk_event_set_device (send_event, device);
9845
9846   gtk_propagate_event (button, send_event);
9847   gdk_event_free (send_event);
9848
9849   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9850   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9851   send_event->button.send_event = TRUE;
9852   send_event->button.time = GDK_CURRENT_TIME;
9853   send_event->button.x = -1;
9854   send_event->button.y = -1;
9855   send_event->button.axes = NULL;
9856   send_event->button.state = 0;
9857   send_event->button.button = GDK_BUTTON_PRIMARY;
9858   send_event->button.x_root = 0;
9859   send_event->button.y_root = 0;
9860   gdk_event_set_device (send_event, device);
9861
9862   gtk_propagate_event (button, send_event);
9863   gdk_event_free (send_event);
9864
9865   /* Kids, don't try this at home */
9866   g_object_ref (button);
9867   gtk_container_remove (GTK_CONTAINER (tree_view), button);
9868   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9869   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
9870   g_object_unref (button);
9871
9872   gtk_widget_get_allocation (button, &button_allocation);
9873   tree_view->priv->drag_column_x = button_allocation.x;
9874   allocation = button_allocation;
9875   allocation.x = 0;
9876   gtk_widget_size_allocate (button, &allocation);
9877   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9878
9879   tree_view->priv->drag_column = column;
9880   gdk_window_show (tree_view->priv->drag_window);
9881
9882   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9883   while (gtk_events_pending ())
9884     gtk_main_iteration ();
9885
9886   tree_view->priv->in_column_drag = TRUE;
9887
9888   gdk_device_grab (pointer,
9889                    tree_view->priv->drag_window,
9890                    GDK_OWNERSHIP_NONE,
9891                    FALSE,
9892                    GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9893                    NULL,
9894                    GDK_CURRENT_TIME);
9895   gdk_device_grab (keyboard,
9896                    tree_view->priv->drag_window,
9897                    GDK_OWNERSHIP_NONE,
9898                    FALSE,
9899                    GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
9900                    NULL,
9901                    GDK_CURRENT_TIME);
9902 }
9903
9904 static void
9905 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9906                                 GtkRBTree          *tree,
9907                                 GtkRBNode          *node)
9908 {
9909   GtkAllocation allocation;
9910   GdkRectangle rect;
9911
9912   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9913     return;
9914
9915   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9916   rect.x = 0;
9917   rect.width = gtk_tree_view_get_expander_size (tree_view);
9918   rect.width = MAX (rect.width, 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 = gtk_tree_view_get_expander_size (tree_view) - 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_render_expander (context, cr,
10133                        area.x, area.y,
10134                        area.width, area.height);
10135
10136   gtk_style_context_restore (context);
10137 }
10138
10139 static void
10140 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
10141
10142 {
10143   GtkTreePath *cursor_path;
10144
10145   if ((tree_view->priv->tree == NULL) ||
10146       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
10147     return;
10148
10149   cursor_path = NULL;
10150   if (tree_view->priv->cursor_node)
10151     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10152                                                   tree_view->priv->cursor_node);
10153
10154   if (cursor_path == NULL)
10155     {
10156       /* Consult the selection before defaulting to the
10157        * first focusable element
10158        */
10159       GList *selected_rows;
10160       GtkTreeModel *model;
10161       GtkTreeSelection *selection;
10162
10163       selection = gtk_tree_view_get_selection (tree_view);
10164       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
10165
10166       if (selected_rows)
10167         {
10168           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
10169           g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free);
10170         }
10171       else
10172         {
10173           cursor_path = gtk_tree_path_new_first ();
10174           search_first_focusable_path (tree_view, &cursor_path,
10175                                        TRUE, NULL, NULL);
10176         }
10177
10178       if (cursor_path)
10179         {
10180           if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
10181             gtk_tree_view_real_set_cursor (tree_view, cursor_path, 0);
10182           else
10183             gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10184         }
10185     }
10186
10187   if (cursor_path)
10188     {
10189       tree_view->priv->draw_keyfocus = TRUE;
10190
10191       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10192       gtk_tree_path_free (cursor_path);
10193
10194       if (tree_view->priv->focus_column == NULL)
10195         {
10196           GList *list;
10197           for (list = tree_view->priv->columns; list; list = list->next)
10198             {
10199               if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
10200                 {
10201                   GtkCellArea *cell_area;
10202
10203                   _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
10204
10205                   /* This happens when the treeview initially grabs focus and there
10206                    * is no column in focus, here we explicitly focus into the first cell */
10207                   cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10208                   if (!gtk_cell_area_get_focus_cell (cell_area))
10209                     {
10210                       gboolean rtl;
10211
10212                       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10213                       gtk_cell_area_focus (cell_area,
10214                                            rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
10215                     }
10216
10217                   break;
10218                 }
10219             }
10220         }
10221     }
10222 }
10223
10224 static void
10225 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
10226                                    gint         count)
10227 {
10228   gint selection_count;
10229   GtkRBTree *new_cursor_tree = NULL;
10230   GtkRBNode *new_cursor_node = NULL;
10231   GtkTreePath *cursor_path = NULL;
10232   gboolean grab_focus = TRUE;
10233   gboolean selectable;
10234   GtkDirectionType direction;
10235   GtkCellArea *cell_area = NULL;
10236   GtkCellRenderer *last_focus_cell = NULL;
10237   GtkTreeIter iter;
10238
10239   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10240     return;
10241
10242   if (tree_view->priv->cursor_node == NULL)
10243     return;
10244
10245   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10246                                                 tree_view->priv->cursor_node);
10247
10248   direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
10249
10250   if (tree_view->priv->focus_column)
10251     cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10252
10253   /* If focus stays in the area for this row, then just return for this round */
10254   if (cell_area && (count == -1 || count == 1) &&
10255       gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path))
10256     {
10257       gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
10258                                                tree_view->priv->model,
10259                                                &iter,
10260                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10261                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10262
10263       /* Save the last cell that had focus, if we hit the end of the view we'll give
10264        * focus back to it. */
10265       last_focus_cell = gtk_cell_area_get_focus_cell (cell_area);
10266
10267       /* If focus stays in the area, no need to change the cursor row */
10268       if (gtk_cell_area_focus (cell_area, direction))
10269         return;
10270     }
10271
10272   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
10273   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
10274                                                       tree_view->priv->cursor_node,
10275                                                       cursor_path);
10276
10277   if (selection_count == 0
10278       && gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE
10279       && !tree_view->priv->modify_selection_pressed
10280       && selectable)
10281     {
10282       /* Don't move the cursor, but just select the current node */
10283       new_cursor_tree = tree_view->priv->cursor_tree;
10284       new_cursor_node = tree_view->priv->cursor_node;
10285     }
10286   else
10287     {
10288       if (count == -1)
10289         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10290                                &new_cursor_tree, &new_cursor_node);
10291       else
10292         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10293                                &new_cursor_tree, &new_cursor_node);
10294     }
10295
10296   gtk_tree_path_free (cursor_path);
10297
10298   if (new_cursor_node)
10299     {
10300       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10301
10302       search_first_focusable_path (tree_view, &cursor_path,
10303                                    (count != -1),
10304                                    &new_cursor_tree,
10305                                    &new_cursor_node);
10306
10307       if (cursor_path)
10308         gtk_tree_path_free (cursor_path);
10309     }
10310
10311   /*
10312    * If the list has only one item and multi-selection is set then select
10313    * the row (if not yet selected).
10314    */
10315   if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE &&
10316       new_cursor_node == NULL)
10317     {
10318       if (count == -1)
10319         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10320                                &new_cursor_tree, &new_cursor_node);
10321       else
10322         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10323                                &new_cursor_tree, &new_cursor_node);
10324
10325       if (new_cursor_node == NULL
10326           && !GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
10327         {
10328           new_cursor_node = tree_view->priv->cursor_node;
10329           new_cursor_tree = tree_view->priv->cursor_tree;
10330         }
10331       else
10332         {
10333           new_cursor_tree = NULL;
10334           new_cursor_node = NULL;
10335         }
10336     }
10337
10338   if (new_cursor_node)
10339     {
10340       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10341       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10342       gtk_tree_path_free (cursor_path);
10343
10344       /* Give focus to the area in the new row */
10345       if (cell_area)
10346         gtk_cell_area_focus (cell_area, direction);
10347     }
10348   else
10349     {
10350       gtk_tree_view_clamp_node_visible (tree_view,
10351                                         tree_view->priv->cursor_tree,
10352                                         tree_view->priv->cursor_node);
10353
10354       if (!tree_view->priv->extend_selection_pressed)
10355         {
10356           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
10357                                           count < 0 ?
10358                                           GTK_DIR_UP : GTK_DIR_DOWN))
10359             {
10360               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10361
10362               if (toplevel)
10363                 gtk_widget_child_focus (toplevel,
10364                                         count < 0 ?
10365                                         GTK_DIR_TAB_BACKWARD :
10366                                         GTK_DIR_TAB_FORWARD);
10367
10368               grab_focus = FALSE;
10369             }
10370         }
10371       else
10372         {
10373           gtk_widget_error_bell (GTK_WIDGET (tree_view));
10374         }
10375
10376       if (cell_area)
10377         gtk_cell_area_set_focus_cell (cell_area, last_focus_cell);
10378     }
10379
10380   if (grab_focus)
10381     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10382 }
10383
10384 static void
10385 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
10386                                         gint         count)
10387 {
10388   GtkTreePath *old_cursor_path = NULL;
10389   GtkTreePath *cursor_path = NULL;
10390   GtkRBTree *start_cursor_tree = NULL;
10391   GtkRBNode *start_cursor_node = NULL;
10392   GtkRBTree *cursor_tree;
10393   GtkRBNode *cursor_node;
10394   gint y;
10395   gint window_y;
10396   gint vertical_separator;
10397
10398   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10399     return;
10400
10401   if (tree_view->priv->cursor_node == NULL)
10402     return;
10403
10404   old_cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10405                                                     tree_view->priv->cursor_node);
10406
10407   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
10408
10409   y = _gtk_rbtree_node_find_offset (tree_view->priv->cursor_tree, tree_view->priv->cursor_node);
10410   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
10411   y += tree_view->priv->cursor_offset;
10412   y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
10413   y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment),  (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
10414
10415   if (y >= tree_view->priv->height)
10416     y = tree_view->priv->height - 1;
10417
10418   tree_view->priv->cursor_offset =
10419     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
10420                              &cursor_tree, &cursor_node);
10421
10422   if (cursor_tree == NULL)
10423     {
10424       /* FIXME: we lost the cursor.  Should we try to get one? */
10425       gtk_tree_path_free (old_cursor_path);
10426       return;
10427     }
10428
10429   if (tree_view->priv->cursor_offset
10430       > gtk_tree_view_get_row_height (tree_view, cursor_node))
10431     {
10432       _gtk_rbtree_next_full (cursor_tree, cursor_node,
10433                              &cursor_tree, &cursor_node);
10434       tree_view->priv->cursor_offset -= gtk_tree_view_get_row_height (tree_view, cursor_node);
10435     }
10436
10437   y -= tree_view->priv->cursor_offset;
10438   cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10439
10440   start_cursor_tree = cursor_tree;
10441   start_cursor_node = cursor_node;
10442
10443   if (! search_first_focusable_path (tree_view, &cursor_path,
10444                                      (count != -1),
10445                                      &cursor_tree, &cursor_node))
10446     {
10447       /* It looks like we reached the end of the view without finding
10448        * a focusable row.  We will step backwards to find the last
10449        * focusable row.
10450        */
10451       cursor_tree = start_cursor_tree;
10452       cursor_node = start_cursor_node;
10453       cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10454
10455       search_first_focusable_path (tree_view, &cursor_path,
10456                                    (count == -1),
10457                                    &cursor_tree, &cursor_node);
10458     }
10459
10460   if (!cursor_path)
10461     goto cleanup;
10462
10463   /* update y */
10464   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10465
10466   gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10467
10468   y -= window_y;
10469   gtk_tree_view_scroll_to_point (tree_view, -1, y);
10470   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10471   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10472
10473   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
10474     gtk_widget_error_bell (GTK_WIDGET (tree_view));
10475
10476   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10477
10478 cleanup:
10479   gtk_tree_path_free (old_cursor_path);
10480   gtk_tree_path_free (cursor_path);
10481 }
10482
10483 static void
10484 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
10485                                       gint         count)
10486 {
10487   GtkTreePath *cursor_path = NULL;
10488   GtkTreeViewColumn *column;
10489   GtkTreeIter iter;
10490   GList *list;
10491   gboolean found_column = FALSE;
10492   gboolean rtl;
10493   GtkDirectionType direction;
10494   GtkCellArea     *cell_area;
10495   GtkCellRenderer *last_focus_cell = NULL;
10496   GtkCellArea     *last_focus_area = NULL;
10497
10498   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10499
10500   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10501     return;
10502
10503   if (tree_view->priv->cursor_node == NULL)
10504     return;
10505
10506   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10507                                                 tree_view->priv->cursor_node);
10508
10509   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
10510     {
10511       gtk_tree_path_free (cursor_path);
10512       return;
10513     }
10514   gtk_tree_path_free (cursor_path);
10515
10516   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
10517   if (tree_view->priv->focus_column)
10518     {
10519       /* Save the cell/area we are moving focus from, if moving the cursor
10520        * by one step hits the end we'll set focus back here */
10521       last_focus_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10522       last_focus_cell = gtk_cell_area_get_focus_cell (last_focus_area);
10523
10524       for (; list; list = (rtl ? list->prev : list->next))
10525         {
10526           if (list->data == tree_view->priv->focus_column)
10527             break;
10528         }
10529     }
10530
10531   direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
10532
10533   while (list)
10534     {
10535       column = list->data;
10536       if (gtk_tree_view_column_get_visible (column) == FALSE)
10537         goto loop_end;
10538
10539       gtk_tree_view_column_cell_set_cell_data (column,
10540                                                tree_view->priv->model,
10541                                                &iter,
10542                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10543                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10544
10545       cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
10546       if (gtk_cell_area_focus (cell_area, direction))
10547         {
10548           _gtk_tree_view_set_focus_column (tree_view, column);
10549           found_column = TRUE;
10550           break;
10551         }
10552
10553     loop_end:
10554       if (count == 1)
10555         list = rtl ? list->prev : list->next;
10556       else
10557         list = rtl ? list->next : list->prev;
10558     }
10559
10560   if (found_column)
10561     {
10562       if (!gtk_tree_view_has_can_focus_cell (tree_view))
10563         _gtk_tree_view_queue_draw_node (tree_view,
10564                                         tree_view->priv->cursor_tree,
10565                                         tree_view->priv->cursor_node,
10566                                         NULL);
10567       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
10568       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10569     }
10570   else
10571     {
10572       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10573
10574       if (last_focus_area)
10575         gtk_cell_area_set_focus_cell (last_focus_area, last_focus_cell);
10576     }
10577
10578   gtk_tree_view_clamp_column_visible (tree_view,
10579                                       tree_view->priv->focus_column, TRUE);
10580 }
10581
10582 static void
10583 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
10584                                      gint         count)
10585 {
10586   GtkRBTree *cursor_tree;
10587   GtkRBNode *cursor_node;
10588   GtkTreePath *path;
10589   GtkTreePath *old_path;
10590
10591   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10592     return;
10593
10594   g_return_if_fail (tree_view->priv->tree != NULL);
10595
10596   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
10597
10598   cursor_tree = tree_view->priv->tree;
10599
10600   if (count == -1)
10601     {
10602       cursor_node = _gtk_rbtree_first (cursor_tree);
10603
10604       /* Now go forward to find the first focusable row. */
10605       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10606       search_first_focusable_path (tree_view, &path,
10607                                    TRUE, &cursor_tree, &cursor_node);
10608     }
10609   else
10610     {
10611       cursor_node = cursor_tree->root;
10612
10613       do
10614         {
10615           while (cursor_node && !_gtk_rbtree_is_nil (cursor_node->right))
10616             cursor_node = cursor_node->right;
10617           if (cursor_node->children == NULL)
10618             break;
10619
10620           cursor_tree = cursor_node->children;
10621           cursor_node = cursor_tree->root;
10622         }
10623       while (1);
10624
10625       /* Now go backwards to find last focusable row. */
10626       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10627       search_first_focusable_path (tree_view, &path,
10628                                    FALSE, &cursor_tree, &cursor_node);
10629     }
10630
10631   if (!path)
10632     goto cleanup;
10633
10634   if (gtk_tree_path_compare (old_path, path))
10635     {
10636       gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
10637       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10638     }
10639   else
10640     {
10641       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10642     }
10643
10644 cleanup:
10645   gtk_tree_path_free (old_path);
10646   gtk_tree_path_free (path);
10647 }
10648
10649 static gboolean
10650 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10651 {
10652   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10653     return FALSE;
10654
10655   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10656     return FALSE;
10657
10658   gtk_tree_selection_select_all (tree_view->priv->selection);
10659
10660   return TRUE;
10661 }
10662
10663 static gboolean
10664 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
10665 {
10666   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10667     return FALSE;
10668
10669   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10670     return FALSE;
10671
10672   gtk_tree_selection_unselect_all (tree_view->priv->selection);
10673
10674   return TRUE;
10675 }
10676
10677 static gboolean
10678 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10679                                       gboolean     start_editing)
10680 {
10681   GtkRBTree *new_tree = NULL;
10682   GtkRBNode *new_node = NULL;
10683   GtkRBTree *cursor_tree = NULL;
10684   GtkRBNode *cursor_node = NULL;
10685   GtkTreePath *cursor_path = NULL;
10686   GtkTreeSelectMode mode = 0;
10687
10688   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10689     return FALSE;
10690
10691   if (tree_view->priv->cursor_node == NULL)
10692     return FALSE;
10693
10694   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10695                                                 tree_view->priv->cursor_node);
10696
10697   _gtk_tree_view_find_node (tree_view, cursor_path,
10698                             &cursor_tree, &cursor_node);
10699
10700   if (cursor_tree == NULL)
10701     {
10702       gtk_tree_path_free (cursor_path);
10703       return FALSE;
10704     }
10705
10706   if (!tree_view->priv->extend_selection_pressed && start_editing &&
10707       tree_view->priv->focus_column)
10708     {
10709       if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE))
10710         {
10711           gtk_tree_path_free (cursor_path);
10712           return TRUE;
10713         }
10714     }
10715
10716   if (tree_view->priv->modify_selection_pressed)
10717     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10718   if (tree_view->priv->extend_selection_pressed)
10719     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10720
10721   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10722                                             cursor_node,
10723                                             cursor_tree,
10724                                             cursor_path,
10725                                             mode,
10726                                             FALSE);
10727
10728   /* We bail out if the original (tree, node) don't exist anymore after
10729    * handling the selection-changed callback.  We do return TRUE because
10730    * the key press has been handled at this point.
10731    */
10732   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10733
10734   if (cursor_tree != new_tree || cursor_node != new_node)
10735     return FALSE;
10736
10737   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10738
10739   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10740   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10741
10742   if (!tree_view->priv->extend_selection_pressed)
10743     gtk_tree_view_row_activated (tree_view, cursor_path,
10744                                  tree_view->priv->focus_column);
10745
10746   gtk_tree_path_free (cursor_path);
10747
10748   return TRUE;
10749 }
10750
10751 static gboolean
10752 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10753 {
10754   GtkRBTree *new_tree = NULL;
10755   GtkRBNode *new_node = NULL;
10756   GtkTreePath *cursor_path = NULL;
10757
10758   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10759     return FALSE;
10760
10761   if (tree_view->priv->cursor_node == NULL)
10762     return FALSE;
10763
10764   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10765                                                 tree_view->priv->cursor_node);
10766
10767   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10768                                             tree_view->priv->cursor_node,
10769                                             tree_view->priv->cursor_tree,
10770                                             cursor_path,
10771                                             GTK_TREE_SELECT_MODE_TOGGLE,
10772                                             FALSE);
10773
10774   /* We bail out if the original (tree, node) don't exist anymore after
10775    * handling the selection-changed callback.  We do return TRUE because
10776    * the key press has been handled at this point.
10777    */
10778   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10779
10780   if (tree_view->priv->cursor_node != new_node)
10781     return FALSE;
10782
10783   gtk_tree_view_clamp_node_visible (tree_view,
10784                                     tree_view->priv->cursor_tree,
10785                                     tree_view->priv->cursor_node);
10786
10787   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10788   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10789   gtk_tree_path_free (cursor_path);
10790
10791   return TRUE;
10792 }
10793
10794 static gboolean
10795 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10796                                                gboolean     logical,
10797                                                gboolean     expand,
10798                                                gboolean     open_all)
10799 {
10800   GtkTreePath *cursor_path = NULL;
10801
10802   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10803     return FALSE;
10804
10805   if (tree_view->priv->cursor_node == NULL)
10806     return FALSE;
10807
10808   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10809                                                 tree_view->priv->cursor_node);
10810
10811   /* Don't handle the event if we aren't an expander */
10812   if (!GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT))
10813     return FALSE;
10814
10815   if (!logical
10816       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10817     expand = !expand;
10818
10819   if (expand)
10820     gtk_tree_view_real_expand_row (tree_view,
10821                                    cursor_path,
10822                                    tree_view->priv->cursor_tree,
10823                                    tree_view->priv->cursor_node,
10824                                    open_all,
10825                                    TRUE);
10826   else
10827     gtk_tree_view_real_collapse_row (tree_view,
10828                                      cursor_path,
10829                                      tree_view->priv->cursor_tree,
10830                                      tree_view->priv->cursor_node,
10831                                      TRUE);
10832
10833   gtk_tree_path_free (cursor_path);
10834
10835   return TRUE;
10836 }
10837
10838 static gboolean
10839 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10840 {
10841   GtkTreePath *cursor_path = NULL;
10842   GdkModifierType state;
10843
10844   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10845     goto out;
10846
10847   if (tree_view->priv->cursor_node == NULL)
10848     goto out;
10849
10850   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10851                                                 tree_view->priv->cursor_node);
10852
10853   if (tree_view->priv->cursor_tree->parent_node)
10854     {
10855       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10856
10857       gtk_tree_path_up (cursor_path);
10858
10859       if (gtk_get_current_event_state (&state))
10860         {
10861           GdkModifierType modify_mod_mask;
10862
10863           modify_mod_mask =
10864             gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
10865                                           GDK_MODIFIER_INTENT_MODIFY_SELECTION);
10866
10867           if ((state & modify_mod_mask) == modify_mod_mask)
10868             tree_view->priv->modify_selection_pressed = TRUE;
10869         }
10870
10871       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10872       gtk_tree_path_free (cursor_path);
10873
10874       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10875
10876       tree_view->priv->modify_selection_pressed = FALSE;
10877
10878       return TRUE;
10879     }
10880
10881  out:
10882
10883   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10884   return FALSE;
10885 }
10886
10887 static gboolean
10888 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10889 {
10890   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
10891   tree_view->priv->typeselect_flush_timeout = 0;
10892
10893   return FALSE;
10894 }
10895
10896 /* Cut and paste from gtkwindow.c */
10897 static void
10898 send_focus_change (GtkWidget *widget,
10899                    GdkDevice *device,
10900                    gboolean   in)
10901 {
10902   GdkDeviceManager *device_manager;
10903   GList *devices, *d;
10904
10905   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
10906   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
10907   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
10908   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
10909
10910   for (d = devices; d; d = d->next)
10911     {
10912       GdkDevice *dev = d->data;
10913       GdkEvent *fevent;
10914       GdkWindow *window;
10915
10916       if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
10917         continue;
10918
10919       window = gtk_widget_get_window (widget);
10920
10921       /* Skip non-master keyboards that haven't
10922        * selected for events from this window
10923        */
10924       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
10925           !gdk_window_get_device_events (window, dev))
10926         continue;
10927
10928       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10929
10930       fevent->focus_change.type = GDK_FOCUS_CHANGE;
10931       fevent->focus_change.window = g_object_ref (window);
10932       fevent->focus_change.in = in;
10933       gdk_event_set_device (fevent, device);
10934
10935       gtk_widget_send_focus_change (widget, fevent);
10936
10937       gdk_event_free (fevent);
10938     }
10939
10940   g_list_free (devices);
10941 }
10942
10943 static void
10944 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10945 {
10946   GtkWidget *frame, *vbox, *toplevel;
10947   GdkScreen *screen;
10948
10949   if (tree_view->priv->search_custom_entry_set)
10950     return;
10951
10952   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10953   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10954
10955    if (tree_view->priv->search_window != NULL)
10956      {
10957        if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10958          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10959                                       GTK_WINDOW (tree_view->priv->search_window));
10960        else if (gtk_window_has_group (GTK_WINDOW (tree_view->priv->search_window)))
10961          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
10962                                          GTK_WINDOW (tree_view->priv->search_window));
10963
10964        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10965
10966        return;
10967      }
10968
10969   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10970   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10971
10972   if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10973     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10974                                  GTK_WINDOW (tree_view->priv->search_window));
10975
10976   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10977                             GDK_WINDOW_TYPE_HINT_UTILITY);
10978   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10979   g_signal_connect (tree_view->priv->search_window, "delete-event",
10980                     G_CALLBACK (gtk_tree_view_search_delete_event),
10981                     tree_view);
10982   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10983                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10984                     tree_view);
10985   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10986                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10987                     tree_view);
10988   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10989                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10990                     tree_view);
10991
10992   frame = gtk_frame_new (NULL);
10993   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10994   gtk_widget_show (frame);
10995   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10996
10997   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10998   gtk_widget_show (vbox);
10999   gtk_container_add (GTK_CONTAINER (frame), vbox);
11000   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
11001
11002   /* add entry */
11003   tree_view->priv->search_entry = gtk_entry_new ();
11004   gtk_widget_show (tree_view->priv->search_entry);
11005   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
11006                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
11007                     tree_view);
11008   g_signal_connect (tree_view->priv->search_entry,
11009                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
11010                     tree_view);
11011
11012   g_signal_connect (_gtk_entry_get_im_context (GTK_ENTRY (tree_view->priv->search_entry)),
11013                     "preedit-changed",
11014                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
11015                     tree_view);
11016
11017   gtk_container_add (GTK_CONTAINER (vbox),
11018                      tree_view->priv->search_entry);
11019
11020   gtk_widget_realize (tree_view->priv->search_entry);
11021 }
11022
11023 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
11024  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
11025  */
11026 static gboolean
11027 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
11028                                              GdkDevice   *device,
11029                                              gboolean     keybinding)
11030 {
11031   /* We only start interactive search if we have focus or the columns
11032    * have focus.  If one of our children have focus, we don't want to
11033    * start the search.
11034    */
11035   GList *list;
11036   gboolean found_focus = FALSE;
11037   GtkWidgetClass *entry_parent_class;
11038
11039   if (!tree_view->priv->enable_search && !keybinding)
11040     return FALSE;
11041
11042   if (tree_view->priv->search_custom_entry_set)
11043     return FALSE;
11044
11045   if (tree_view->priv->search_window != NULL &&
11046       gtk_widget_get_visible (tree_view->priv->search_window))
11047     return TRUE;
11048
11049   for (list = tree_view->priv->columns; list; list = list->next)
11050     {
11051       GtkTreeViewColumn *column;
11052       GtkWidget         *button;
11053
11054       column = list->data;
11055       if (!gtk_tree_view_column_get_visible (column))
11056         continue;
11057
11058       button = gtk_tree_view_column_get_button (column);
11059       if (gtk_widget_has_focus (button))
11060         {
11061           found_focus = TRUE;
11062           break;
11063         }
11064     }
11065
11066   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
11067     found_focus = TRUE;
11068
11069   if (!found_focus)
11070     return FALSE;
11071
11072   if (tree_view->priv->search_column < 0)
11073     return FALSE;
11074
11075   gtk_tree_view_ensure_interactive_directory (tree_view);
11076
11077   if (keybinding)
11078     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
11079
11080   /* done, show it */
11081   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
11082   gtk_widget_show (tree_view->priv->search_window);
11083   if (tree_view->priv->search_entry_changed_id == 0)
11084     {
11085       tree_view->priv->search_entry_changed_id =
11086         g_signal_connect (tree_view->priv->search_entry, "changed",
11087                           G_CALLBACK (gtk_tree_view_search_init),
11088                           tree_view);
11089     }
11090
11091   tree_view->priv->typeselect_flush_timeout =
11092     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
11093                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
11094                    tree_view);
11095
11096   /* Grab focus will select all the text.  We don't want that to happen, so we
11097    * call the parent instance and bypass the selection change.  This is probably
11098    * really non-kosher. */
11099   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
11100   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
11101
11102   /* send focus-in event */
11103   send_focus_change (tree_view->priv->search_entry, device, TRUE);
11104
11105   /* search first matching iter */
11106   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
11107
11108   return TRUE;
11109 }
11110
11111 static gboolean
11112 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
11113 {
11114   return gtk_tree_view_real_start_interactive_search (tree_view,
11115                                                       gtk_get_current_event_device (),
11116                                                       TRUE);
11117 }
11118
11119 /* this function returns the new width of the column being resized given
11120  * the column and x position of the cursor; the x cursor position is passed
11121  * in as a pointer and automagicly corrected if it's beyond min/max limits
11122  */
11123 static gint
11124 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
11125                                 gint       i,
11126                                 gint      *x)
11127 {
11128   GtkAllocation allocation;
11129   GtkTreeViewColumn *column;
11130   GtkRequisition button_req;
11131   gint max_width, min_width;
11132   gint width;
11133   gboolean rtl;
11134
11135   /* first translate the x position from widget->window
11136    * to clist->clist_window
11137    */
11138   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
11139   column = g_list_nth (tree_view->priv->columns, i)->data;
11140   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
11141   width = rtl ? (allocation.x + allocation.width - *x) : (*x - allocation.x);
11142
11143   /* Clamp down the value */
11144   min_width = gtk_tree_view_column_get_min_width (column);
11145   if (min_width == -1)
11146     {
11147       gtk_widget_get_preferred_size (gtk_tree_view_column_get_button (column), &button_req, NULL);
11148       width = MAX (button_req.width, width);
11149     }
11150   else
11151     width = MAX (min_width, width);
11152
11153   max_width = gtk_tree_view_column_get_max_width (column);
11154   if (max_width != -1)
11155     width = MIN (width, max_width);
11156
11157   *x = rtl ? (allocation.x + allocation.width - width) : (allocation.x + width);
11158
11159   return width;
11160 }
11161
11162
11163 /* FIXME this adjust_allocation is a big cut-and-paste from
11164  * GtkCList, needs to be some "official" way to do this
11165  * factored out.
11166  */
11167 typedef struct
11168 {
11169   GdkWindow *window;
11170   int dx;
11171   int dy;
11172 } ScrollData;
11173
11174 /* The window to which widget->window is relative */
11175 #define ALLOCATION_WINDOW(widget)               \
11176    (!gtk_widget_get_has_window (widget) ?                   \
11177     gtk_widget_get_window (widget) :                        \
11178     gdk_window_get_parent (gtk_widget_get_window (widget)))
11179
11180 static void
11181 adjust_allocation_recurse (GtkWidget *widget,
11182                            gpointer   data)
11183 {
11184   GtkAllocation allocation;
11185   ScrollData *scroll_data = data;
11186
11187   /* Need to really size allocate instead of just poking
11188    * into widget->allocation if the widget is not realized.
11189    * FIXME someone figure out why this was.
11190    */
11191   gtk_widget_get_allocation (widget, &allocation);
11192   if (!gtk_widget_get_realized (widget))
11193     {
11194       if (gtk_widget_get_visible (widget))
11195         {
11196           GdkRectangle tmp_rectangle = allocation;
11197           tmp_rectangle.x += scroll_data->dx;
11198           tmp_rectangle.y += scroll_data->dy;
11199
11200           gtk_widget_size_allocate (widget, &tmp_rectangle);
11201         }
11202     }
11203   else
11204     {
11205       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
11206         {
11207           allocation.x += scroll_data->dx;
11208           allocation.y += scroll_data->dy;
11209           gtk_widget_set_allocation (widget, &allocation);
11210
11211           if (GTK_IS_CONTAINER (widget))
11212             gtk_container_forall (GTK_CONTAINER (widget),
11213                                   adjust_allocation_recurse,
11214                                   data);
11215         }
11216     }
11217 }
11218
11219 static void
11220 adjust_allocation (GtkWidget *widget,
11221                    int        dx,
11222                    int        dy)
11223 {
11224   ScrollData scroll_data;
11225
11226   if (gtk_widget_get_realized (widget))
11227     scroll_data.window = ALLOCATION_WINDOW (widget);
11228   else
11229     scroll_data.window = NULL;
11230
11231   scroll_data.dx = dx;
11232   scroll_data.dy = dy;
11233
11234   adjust_allocation_recurse (widget, &scroll_data);
11235 }
11236
11237 /* Callbacks */
11238 static void
11239 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
11240                                   GtkTreeView   *tree_view)
11241 {
11242   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11243     {
11244       gint dy;
11245
11246       gdk_window_move (tree_view->priv->bin_window,
11247                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11248                        gtk_tree_view_get_effective_header_height (tree_view));
11249       gdk_window_move (tree_view->priv->header_window,
11250                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11251                        0);
11252       dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11253       if (dy)
11254         {
11255           update_prelight (tree_view,
11256                            tree_view->priv->event_last_x,
11257                            tree_view->priv->event_last_y - dy);
11258
11259           if (tree_view->priv->edited_column)
11260             {
11261               GList *list;
11262               GtkTreeViewChild *child = NULL;
11263               GtkCellEditable *edit_widget;
11264               GtkCellArea *area;
11265
11266               area        = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column));
11267               edit_widget = gtk_cell_area_get_edit_widget (area);
11268               if (GTK_IS_WIDGET (edit_widget))
11269                 {
11270                   adjust_allocation (GTK_WIDGET (edit_widget), 0, dy);
11271
11272                   for (list = tree_view->priv->children; list; list = list->next)
11273                     {
11274                       child = (GtkTreeViewChild *)list->data;
11275                       if (child->widget == GTK_WIDGET (edit_widget))
11276                         {
11277                           child->y += dy;
11278                           break;
11279                         }
11280                     }
11281                 }
11282             }
11283         }
11284       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
11285
11286       if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
11287         {
11288           /* update our dy and top_row */
11289           tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11290
11291           if (!tree_view->priv->in_top_row_to_dy)
11292             gtk_tree_view_dy_to_top_row (tree_view);
11293         }
11294     }
11295 }
11296
11297 \f
11298
11299 /* Public methods
11300  */
11301
11302 /**
11303  * gtk_tree_view_new:
11304  *
11305  * Creates a new #GtkTreeView widget.
11306  *
11307  * Return value: A newly created #GtkTreeView widget.
11308  **/
11309 GtkWidget *
11310 gtk_tree_view_new (void)
11311 {
11312   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
11313 }
11314
11315 /**
11316  * gtk_tree_view_new_with_model:
11317  * @model: the model.
11318  *
11319  * Creates a new #GtkTreeView widget with the model initialized to @model.
11320  *
11321  * Return value: A newly created #GtkTreeView widget.
11322  **/
11323 GtkWidget *
11324 gtk_tree_view_new_with_model (GtkTreeModel *model)
11325 {
11326   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
11327 }
11328
11329 /* Public Accessors
11330  */
11331
11332 /**
11333  * gtk_tree_view_get_model:
11334  * @tree_view: a #GtkTreeView
11335  *
11336  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
11337  * model is unset.
11338  *
11339  * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
11340  **/
11341 GtkTreeModel *
11342 gtk_tree_view_get_model (GtkTreeView *tree_view)
11343 {
11344   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11345
11346   return tree_view->priv->model;
11347 }
11348
11349 /**
11350  * gtk_tree_view_set_model:
11351  * @tree_view: A #GtkTreeView.
11352  * @model: (allow-none): The model.
11353  *
11354  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
11355  * set, it will remove it before setting the new model.  If @model is %NULL,
11356  * then it will unset the old model.
11357  **/
11358 void
11359 gtk_tree_view_set_model (GtkTreeView  *tree_view,
11360                          GtkTreeModel *model)
11361 {
11362   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11363   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
11364
11365   if (model == tree_view->priv->model)
11366     return;
11367
11368   if (tree_view->priv->scroll_to_path)
11369     {
11370       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11371       tree_view->priv->scroll_to_path = NULL;
11372     }
11373
11374   if (tree_view->priv->rubber_band_status)
11375     gtk_tree_view_stop_rubber_band (tree_view);
11376
11377   if (tree_view->priv->model)
11378     {
11379       GList *tmplist = tree_view->priv->columns;
11380
11381       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
11382       gtk_tree_view_stop_editing (tree_view, TRUE);
11383
11384       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11385                                             gtk_tree_view_row_changed,
11386                                             tree_view);
11387       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11388                                             gtk_tree_view_row_inserted,
11389                                             tree_view);
11390       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11391                                             gtk_tree_view_row_has_child_toggled,
11392                                             tree_view);
11393       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11394                                             gtk_tree_view_row_deleted,
11395                                             tree_view);
11396       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11397                                             gtk_tree_view_rows_reordered,
11398                                             tree_view);
11399
11400       for (; tmplist; tmplist = tmplist->next)
11401         _gtk_tree_view_column_unset_model (tmplist->data,
11402                                            tree_view->priv->model);
11403
11404       if (tree_view->priv->tree)
11405         gtk_tree_view_free_rbtree (tree_view);
11406
11407       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
11408       tree_view->priv->drag_dest_row = NULL;
11409       gtk_tree_row_reference_free (tree_view->priv->anchor);
11410       tree_view->priv->anchor = NULL;
11411       gtk_tree_row_reference_free (tree_view->priv->top_row);
11412       tree_view->priv->top_row = NULL;
11413       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11414       tree_view->priv->scroll_to_path = NULL;
11415
11416       tree_view->priv->scroll_to_column = NULL;
11417
11418       g_object_unref (tree_view->priv->model);
11419
11420       tree_view->priv->search_column = -1;
11421       tree_view->priv->fixed_height_check = 0;
11422       tree_view->priv->fixed_height = -1;
11423       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
11424       tree_view->priv->last_button_x = -1;
11425       tree_view->priv->last_button_y = -1;
11426     }
11427
11428   tree_view->priv->model = model;
11429
11430   if (tree_view->priv->model)
11431     {
11432       gint i;
11433       GtkTreePath *path;
11434       GtkTreeIter iter;
11435       GtkTreeModelFlags flags;
11436
11437       if (tree_view->priv->search_column == -1)
11438         {
11439           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
11440             {
11441               GType type = gtk_tree_model_get_column_type (model, i);
11442
11443               if (g_value_type_transformable (type, G_TYPE_STRING))
11444                 {
11445                   tree_view->priv->search_column = i;
11446                   break;
11447                 }
11448             }
11449         }
11450
11451       g_object_ref (tree_view->priv->model);
11452       g_signal_connect (tree_view->priv->model,
11453                         "row-changed",
11454                         G_CALLBACK (gtk_tree_view_row_changed),
11455                         tree_view);
11456       g_signal_connect (tree_view->priv->model,
11457                         "row-inserted",
11458                         G_CALLBACK (gtk_tree_view_row_inserted),
11459                         tree_view);
11460       g_signal_connect (tree_view->priv->model,
11461                         "row-has-child-toggled",
11462                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
11463                         tree_view);
11464       g_signal_connect (tree_view->priv->model,
11465                         "row-deleted",
11466                         G_CALLBACK (gtk_tree_view_row_deleted),
11467                         tree_view);
11468       g_signal_connect (tree_view->priv->model,
11469                         "rows-reordered",
11470                         G_CALLBACK (gtk_tree_view_rows_reordered),
11471                         tree_view);
11472
11473       flags = gtk_tree_model_get_flags (tree_view->priv->model);
11474       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
11475         tree_view->priv->is_list = TRUE;
11476       else
11477         tree_view->priv->is_list = FALSE;
11478
11479       path = gtk_tree_path_new_first ();
11480       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
11481         {
11482           tree_view->priv->tree = _gtk_rbtree_new ();
11483           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
11484           _gtk_tree_view_accessible_add (tree_view, tree_view->priv->tree, NULL);
11485         }
11486       gtk_tree_path_free (path);
11487
11488       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
11489       install_presize_handler (tree_view);
11490     }
11491
11492   gtk_tree_view_real_set_cursor (tree_view, NULL, CURSOR_INVALID);
11493
11494   g_object_notify (G_OBJECT (tree_view), "model");
11495
11496   if (tree_view->priv->selection)
11497   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
11498
11499   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11500     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11501 }
11502
11503 /**
11504  * gtk_tree_view_get_selection:
11505  * @tree_view: A #GtkTreeView.
11506  *
11507  * Gets the #GtkTreeSelection associated with @tree_view.
11508  *
11509  * Return value: (transfer none): A #GtkTreeSelection object.
11510  **/
11511 GtkTreeSelection *
11512 gtk_tree_view_get_selection (GtkTreeView *tree_view)
11513 {
11514   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11515
11516   return tree_view->priv->selection;
11517 }
11518
11519 /**
11520  * gtk_tree_view_get_hadjustment:
11521  * @tree_view: A #GtkTreeView
11522  *
11523  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
11524  *
11525  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11526  *     if none is currently being used.
11527  *
11528  * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment()
11529  **/
11530 GtkAdjustment *
11531 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
11532 {
11533   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11534
11535   return gtk_tree_view_do_get_hadjustment (tree_view);
11536 }
11537
11538 static GtkAdjustment *
11539 gtk_tree_view_do_get_hadjustment (GtkTreeView *tree_view)
11540 {
11541   return tree_view->priv->hadjustment;
11542 }
11543
11544 /**
11545  * gtk_tree_view_set_hadjustment:
11546  * @tree_view: A #GtkTreeView
11547  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11548  *
11549  * Sets the #GtkAdjustment for the current horizontal aspect.
11550  *
11551  * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment()
11552  **/
11553 void
11554 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
11555                                GtkAdjustment *adjustment)
11556 {
11557   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11558   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11559
11560   gtk_tree_view_do_set_hadjustment (tree_view, adjustment);
11561 }
11562
11563 static void
11564 gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
11565                                   GtkAdjustment *adjustment)
11566 {
11567   GtkTreeViewPrivate *priv = tree_view->priv;
11568
11569   if (adjustment && priv->hadjustment == adjustment)
11570     return;
11571
11572   if (priv->hadjustment != NULL)
11573     {
11574       g_signal_handlers_disconnect_by_func (priv->hadjustment,
11575                                             gtk_tree_view_adjustment_changed,
11576                                             tree_view);
11577       g_object_unref (priv->hadjustment);
11578     }
11579
11580   if (adjustment == NULL)
11581     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11582                                      0.0, 0.0, 0.0);
11583
11584   g_signal_connect (adjustment, "value-changed",
11585                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11586   priv->hadjustment = g_object_ref_sink (adjustment);
11587   /* FIXME: Adjustment should probably be populated here with fresh values, but
11588    * internal details are too complicated for me to decipher right now.
11589    */
11590   gtk_tree_view_adjustment_changed (NULL, tree_view);
11591
11592   g_object_notify (G_OBJECT (tree_view), "hadjustment");
11593 }
11594
11595 /**
11596  * gtk_tree_view_get_vadjustment:
11597  * @tree_view: A #GtkTreeView
11598  *
11599  * Gets the #GtkAdjustment currently being used for the vertical aspect.
11600  *
11601  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11602  *     if none is currently being used.
11603  *
11604  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
11605  **/
11606 GtkAdjustment *
11607 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
11608 {
11609   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11610
11611   return gtk_tree_view_do_get_vadjustment (tree_view);
11612 }
11613
11614 static GtkAdjustment *
11615 gtk_tree_view_do_get_vadjustment (GtkTreeView *tree_view)
11616 {
11617   return tree_view->priv->vadjustment;
11618 }
11619
11620 /**
11621  * gtk_tree_view_set_vadjustment:
11622  * @tree_view: A #GtkTreeView
11623  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11624  *
11625  * Sets the #GtkAdjustment for the current vertical aspect.
11626  *
11627  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
11628  **/
11629 void
11630 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
11631                                GtkAdjustment *adjustment)
11632 {
11633   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11634   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11635
11636   gtk_tree_view_do_set_vadjustment (tree_view, adjustment);
11637 }
11638
11639 static void
11640 gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
11641                                   GtkAdjustment *adjustment)
11642 {
11643   GtkTreeViewPrivate *priv = tree_view->priv;
11644
11645   if (adjustment && priv->vadjustment == adjustment)
11646     return;
11647
11648   if (priv->vadjustment != NULL)
11649     {
11650       g_signal_handlers_disconnect_by_func (priv->vadjustment,
11651                                             gtk_tree_view_adjustment_changed,
11652                                             tree_view);
11653       g_object_unref (priv->vadjustment);
11654     }
11655
11656   if (adjustment == NULL)
11657     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11658                                      0.0, 0.0, 0.0);
11659
11660   g_signal_connect (adjustment, "value-changed",
11661                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11662   priv->vadjustment = g_object_ref_sink (adjustment);
11663   /* FIXME: Adjustment should probably be populated here with fresh values, but
11664    * internal details are too complicated for me to decipher right now.
11665    */
11666   gtk_tree_view_adjustment_changed (NULL, tree_view);
11667   g_object_notify (G_OBJECT (tree_view), "vadjustment");
11668 }
11669
11670 /* Column and header operations */
11671
11672 /**
11673  * gtk_tree_view_get_headers_visible:
11674  * @tree_view: A #GtkTreeView.
11675  *
11676  * Returns %TRUE if the headers on the @tree_view are visible.
11677  *
11678  * Return value: Whether the headers are visible or not.
11679  **/
11680 gboolean
11681 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
11682 {
11683   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11684
11685   return tree_view->priv->headers_visible;
11686 }
11687
11688 /**
11689  * gtk_tree_view_set_headers_visible:
11690  * @tree_view: A #GtkTreeView.
11691  * @headers_visible: %TRUE if the headers are visible
11692  *
11693  * Sets the visibility state of the headers.
11694  **/
11695 void
11696 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
11697                                    gboolean     headers_visible)
11698 {
11699   gint x, y;
11700   GList *list;
11701   GtkTreeViewColumn *column;
11702   GtkAllocation allocation;
11703   GtkWidget *button;
11704
11705   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11706
11707   headers_visible = !! headers_visible;
11708
11709   if (tree_view->priv->headers_visible == headers_visible)
11710     return;
11711
11712   tree_view->priv->headers_visible = headers_visible == TRUE;
11713
11714   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11715     {
11716       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
11717       if (headers_visible)
11718         {
11719           gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11720           gdk_window_move_resize (tree_view->priv->bin_window,
11721                                   x, y  + gtk_tree_view_get_effective_header_height (tree_view),
11722                                   tree_view->priv->width, allocation.height -  + gtk_tree_view_get_effective_header_height (tree_view));
11723
11724           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
11725             gtk_tree_view_map_buttons (tree_view);
11726         }
11727       else
11728         {
11729           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
11730
11731           for (list = tree_view->priv->columns; list; list = list->next)
11732             {
11733               column = list->data;
11734               button = gtk_tree_view_column_get_button (column);
11735
11736               gtk_widget_hide (button);
11737               gtk_widget_unmap (button);
11738             }
11739           gdk_window_hide (tree_view->priv->header_window);
11740         }
11741     }
11742
11743   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11744   gtk_adjustment_configure (tree_view->priv->vadjustment,
11745                             gtk_adjustment_get_value (tree_view->priv->vadjustment),
11746                             0,
11747                             tree_view->priv->height,
11748                             gtk_adjustment_get_step_increment (tree_view->priv->vadjustment),
11749                             (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2,
11750                             allocation.height - gtk_tree_view_get_effective_header_height (tree_view));
11751
11752   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11753
11754   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11755 }
11756
11757 /**
11758  * gtk_tree_view_columns_autosize:
11759  * @tree_view: A #GtkTreeView.
11760  *
11761  * Resizes all columns to their optimal width. Only works after the
11762  * treeview has been realized.
11763  **/
11764 void
11765 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11766 {
11767   gboolean dirty = FALSE;
11768   GList *list;
11769   GtkTreeViewColumn *column;
11770
11771   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11772
11773   for (list = tree_view->priv->columns; list; list = list->next)
11774     {
11775       column = list->data;
11776       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11777         continue;
11778       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11779       dirty = TRUE;
11780     }
11781
11782   if (dirty)
11783     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11784 }
11785
11786 /**
11787  * gtk_tree_view_set_headers_clickable:
11788  * @tree_view: A #GtkTreeView.
11789  * @setting: %TRUE if the columns are clickable.
11790  *
11791  * Allow the column title buttons to be clicked.
11792  **/
11793 void
11794 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11795                                      gboolean   setting)
11796 {
11797   GList *list;
11798
11799   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11800
11801   for (list = tree_view->priv->columns; list; list = list->next)
11802     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11803
11804   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11805 }
11806
11807
11808 /**
11809  * gtk_tree_view_get_headers_clickable:
11810  * @tree_view: A #GtkTreeView.
11811  *
11812  * Returns whether all header columns are clickable.
11813  *
11814  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11815  *
11816  * Since: 2.10
11817  **/
11818 gboolean
11819 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11820 {
11821   GList *list;
11822
11823   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11824
11825   for (list = tree_view->priv->columns; list; list = list->next)
11826     if (!gtk_tree_view_column_get_clickable (GTK_TREE_VIEW_COLUMN (list->data)))
11827       return FALSE;
11828
11829   return TRUE;
11830 }
11831
11832 /**
11833  * gtk_tree_view_set_rules_hint:
11834  * @tree_view: a #GtkTreeView
11835  * @setting: %TRUE if the tree requires reading across rows
11836  *
11837  * This function tells GTK+ that the user interface for your
11838  * application requires users to read across tree rows and associate
11839  * cells with one another. By default, GTK+ will then render the tree
11840  * with alternating row colors. Do <emphasis>not</emphasis> use it
11841  * just because you prefer the appearance of the ruled tree; that's a
11842  * question for the theme. Some themes will draw tree rows in
11843  * alternating colors even when rules are turned off, and users who
11844  * prefer that appearance all the time can choose those themes. You
11845  * should call this function only as a <emphasis>semantic</emphasis>
11846  * hint to the theme engine that your tree makes alternating colors
11847  * useful from a functional standpoint (since it has lots of columns,
11848  * generally).
11849  *
11850  **/
11851 void
11852 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11853                               gboolean      setting)
11854 {
11855   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11856
11857   setting = setting != FALSE;
11858
11859   if (tree_view->priv->has_rules != setting)
11860     {
11861       tree_view->priv->has_rules = setting;
11862       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11863     }
11864
11865   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11866 }
11867
11868 /**
11869  * gtk_tree_view_get_rules_hint:
11870  * @tree_view: a #GtkTreeView
11871  *
11872  * Gets the setting set by gtk_tree_view_set_rules_hint().
11873  *
11874  * Return value: %TRUE if rules are useful for the user of this tree
11875  **/
11876 gboolean
11877 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11878 {
11879   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11880
11881   return tree_view->priv->has_rules;
11882 }
11883
11884 /* Public Column functions
11885  */
11886
11887 /**
11888  * gtk_tree_view_append_column:
11889  * @tree_view: A #GtkTreeView.
11890  * @column: The #GtkTreeViewColumn to add.
11891  *
11892  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11893  * mode enabled, then @column must have its "sizing" property set to be
11894  * GTK_TREE_VIEW_COLUMN_FIXED.
11895  *
11896  * Return value: The number of columns in @tree_view after appending.
11897  **/
11898 gint
11899 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11900                              GtkTreeViewColumn *column)
11901 {
11902   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11903   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11904   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11905
11906   return gtk_tree_view_insert_column (tree_view, column, -1);
11907 }
11908
11909 void
11910 _gtk_tree_view_reset_header_styles (GtkTreeView *tree_view)
11911 {
11912   GList *columns;
11913
11914   for (columns = tree_view->priv->columns; columns; columns = columns->next)
11915     {
11916       GtkTreeViewColumn *column = columns->data;
11917       GtkWidget *header_widget;
11918
11919       if (!gtk_tree_view_column_get_visible (column))
11920         continue;
11921
11922       header_widget = gtk_tree_view_column_get_widget (column);
11923
11924       if (!header_widget)
11925         header_widget = gtk_tree_view_column_get_button (column);
11926
11927       _gtk_widget_invalidate_style_context (header_widget, GTK_CSS_CHANGE_POSITION | GTK_CSS_CHANGE_SIBLING_POSITION);
11928     }
11929 }
11930
11931
11932 /**
11933  * gtk_tree_view_remove_column:
11934  * @tree_view: A #GtkTreeView.
11935  * @column: The #GtkTreeViewColumn to remove.
11936  *
11937  * Removes @column from @tree_view.
11938  *
11939  * Return value: The number of columns in @tree_view after removing.
11940  **/
11941 gint
11942 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11943                              GtkTreeViewColumn *column)
11944 {
11945   guint position;
11946
11947   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11948   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11949   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1);
11950
11951   if (tree_view->priv->focus_column == column)
11952     _gtk_tree_view_set_focus_column (tree_view, NULL);
11953
11954   if (tree_view->priv->edited_column == column)
11955     {
11956       gtk_tree_view_stop_editing (tree_view, TRUE);
11957
11958       /* no need to, but just to be sure ... */
11959       tree_view->priv->edited_column = NULL;
11960     }
11961
11962   if (tree_view->priv->expander_column == column)
11963     tree_view->priv->expander_column = NULL;
11964
11965   g_signal_handlers_disconnect_by_func (column,
11966                                         G_CALLBACK (column_sizing_notify),
11967                                         tree_view);
11968
11969   _gtk_tree_view_column_unset_tree_view (column);
11970
11971   position = g_list_index (tree_view->priv->columns, column);
11972
11973   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11974   tree_view->priv->n_columns--;
11975
11976   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11977     {
11978       GList *list;
11979
11980       _gtk_tree_view_column_unrealize_button (column);
11981       for (list = tree_view->priv->columns; list; list = list->next)
11982         {
11983           GtkTreeViewColumn *tmp_column;
11984
11985           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11986           if (gtk_tree_view_column_get_visible (tmp_column))
11987             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
11988         }
11989
11990       if (tree_view->priv->n_columns == 0 &&
11991           gtk_tree_view_get_headers_visible (tree_view))
11992         gdk_window_hide (tree_view->priv->header_window);
11993
11994       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11995     }
11996
11997   _gtk_tree_view_reset_header_styles (tree_view);
11998
11999   _gtk_tree_view_accessible_remove_column (tree_view, column, position);
12000
12001   g_object_unref (column);
12002   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12003
12004   return tree_view->priv->n_columns;
12005 }
12006
12007 /**
12008  * gtk_tree_view_insert_column:
12009  * @tree_view: A #GtkTreeView.
12010  * @column: The #GtkTreeViewColumn to be inserted.
12011  * @position: The position to insert @column in.
12012  *
12013  * This inserts the @column into the @tree_view at @position.  If @position is
12014  * -1, then the column is inserted at the end. If @tree_view has
12015  * "fixed_height" mode enabled, then @column must have its "sizing" property
12016  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
12017  *
12018  * Return value: The number of columns in @tree_view after insertion.
12019  **/
12020 gint
12021 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
12022                              GtkTreeViewColumn *column,
12023                              gint               position)
12024 {
12025   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12026   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
12027   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
12028
12029   if (tree_view->priv->fixed_height_mode)
12030     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
12031                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
12032
12033   if (position < 0 || position > tree_view->priv->n_columns)
12034     position = tree_view->priv->n_columns;
12035
12036   g_object_ref_sink (column);
12037
12038   if (tree_view->priv->n_columns == 0 &&
12039       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
12040       gtk_tree_view_get_headers_visible (tree_view))
12041     {
12042       gdk_window_show (tree_view->priv->header_window);
12043     }
12044
12045   g_signal_connect (column, "notify::sizing",
12046                     G_CALLBACK (column_sizing_notify), tree_view);
12047
12048   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
12049                                             column, position);
12050   tree_view->priv->n_columns++;
12051
12052   _gtk_tree_view_column_set_tree_view (column, tree_view);
12053
12054   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12055     {
12056       GList *list;
12057
12058       _gtk_tree_view_column_realize_button (column);
12059
12060       for (list = tree_view->priv->columns; list; list = list->next)
12061         {
12062           column = GTK_TREE_VIEW_COLUMN (list->data);
12063           if (gtk_tree_view_column_get_visible (column))
12064             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12065         }
12066       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12067     }
12068
12069   _gtk_tree_view_reset_header_styles (tree_view);
12070
12071   _gtk_tree_view_accessible_add_column (tree_view, column, position);
12072
12073   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12074
12075   return tree_view->priv->n_columns;
12076 }
12077
12078 /**
12079  * gtk_tree_view_insert_column_with_attributes:
12080  * @tree_view: A #GtkTreeView
12081  * @position: The position to insert the new column in
12082  * @title: The title to set the header to
12083  * @cell: The #GtkCellRenderer
12084  * @...: A %NULL-terminated list of attributes
12085  *
12086  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
12087  * @position.  If @position is -1, then the newly created column is inserted at
12088  * the end.  The column is initialized with the attributes given. If @tree_view
12089  * has "fixed_height" mode enabled, then the new column will have its sizing
12090  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12091  *
12092  * Return value: The number of columns in @tree_view after insertion.
12093  **/
12094 gint
12095 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
12096                                              gint             position,
12097                                              const gchar     *title,
12098                                              GtkCellRenderer *cell,
12099                                              ...)
12100 {
12101   GtkTreeViewColumn *column;
12102   gchar *attribute;
12103   va_list args;
12104   gint column_id;
12105
12106   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12107
12108   column = gtk_tree_view_column_new ();
12109   if (tree_view->priv->fixed_height_mode)
12110     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12111
12112   gtk_tree_view_column_set_title (column, title);
12113   gtk_tree_view_column_pack_start (column, cell, TRUE);
12114
12115   va_start (args, cell);
12116
12117   attribute = va_arg (args, gchar *);
12118
12119   while (attribute != NULL)
12120     {
12121       column_id = va_arg (args, gint);
12122       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
12123       attribute = va_arg (args, gchar *);
12124     }
12125
12126   va_end (args);
12127
12128   return gtk_tree_view_insert_column (tree_view, column, position);
12129 }
12130
12131 /**
12132  * gtk_tree_view_insert_column_with_data_func:
12133  * @tree_view: a #GtkTreeView
12134  * @position: Position to insert, -1 for append
12135  * @title: column title
12136  * @cell: cell renderer for column
12137  * @func: function to set attributes of cell renderer
12138  * @data: data for @func
12139  * @dnotify: destroy notifier for @data
12140  *
12141  * Convenience function that inserts a new column into the #GtkTreeView
12142  * with the given cell renderer and a #GtkTreeCellDataFunc to set cell renderer
12143  * attributes (normally using data from the model). See also
12144  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
12145  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
12146  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12147  *
12148  * Return value: number of columns in the tree view post-insert
12149  **/
12150 gint
12151 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
12152                                              gint                       position,
12153                                              const gchar               *title,
12154                                              GtkCellRenderer           *cell,
12155                                              GtkTreeCellDataFunc        func,
12156                                              gpointer                   data,
12157                                              GDestroyNotify             dnotify)
12158 {
12159   GtkTreeViewColumn *column;
12160
12161   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12162
12163   column = gtk_tree_view_column_new ();
12164   if (tree_view->priv->fixed_height_mode)
12165     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12166
12167   gtk_tree_view_column_set_title (column, title);
12168   gtk_tree_view_column_pack_start (column, cell, TRUE);
12169   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
12170
12171   return gtk_tree_view_insert_column (tree_view, column, position);
12172 }
12173
12174 /**
12175  * gtk_tree_view_get_n_columns:
12176  * @tree_view: a #GtkTreeView
12177  *
12178  * Queries the number of columns in the given @tree_view.
12179  *
12180  * Returns: The number of columns in the @tree_view
12181  *
12182  * Since: 3.4
12183  **/
12184 guint
12185 gtk_tree_view_get_n_columns (GtkTreeView *tree_view)
12186 {
12187   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
12188
12189   return tree_view->priv->n_columns;
12190 }
12191
12192 /**
12193  * gtk_tree_view_get_column:
12194  * @tree_view: A #GtkTreeView.
12195  * @n: The position of the column, counting from 0.
12196  *
12197  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
12198  *
12199  * Return value: (transfer none): The #GtkTreeViewColumn, or %NULL if the
12200  *     position is outside the range of columns.
12201  **/
12202 GtkTreeViewColumn *
12203 gtk_tree_view_get_column (GtkTreeView *tree_view,
12204                           gint         n)
12205 {
12206   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12207
12208   if (n < 0 || n >= tree_view->priv->n_columns)
12209     return NULL;
12210
12211   if (tree_view->priv->columns == NULL)
12212     return NULL;
12213
12214   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
12215 }
12216
12217 /**
12218  * gtk_tree_view_get_columns:
12219  * @tree_view: A #GtkTreeView
12220  *
12221  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
12222  * The returned list must be freed with g_list_free ().
12223  *
12224  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
12225  **/
12226 GList *
12227 gtk_tree_view_get_columns (GtkTreeView *tree_view)
12228 {
12229   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12230
12231   return g_list_copy (tree_view->priv->columns);
12232 }
12233
12234 /**
12235  * gtk_tree_view_move_column_after:
12236  * @tree_view: A #GtkTreeView
12237  * @column: The #GtkTreeViewColumn to be moved.
12238  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
12239  *
12240  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
12241  * @column is placed in the first position.
12242  **/
12243 void
12244 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
12245                                  GtkTreeViewColumn *column,
12246                                  GtkTreeViewColumn *base_column)
12247 {
12248   GList *column_list_el, *base_el = NULL;
12249
12250   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12251
12252   column_list_el = g_list_find (tree_view->priv->columns, column);
12253   g_return_if_fail (column_list_el != NULL);
12254
12255   if (base_column)
12256     {
12257       base_el = g_list_find (tree_view->priv->columns, base_column);
12258       g_return_if_fail (base_el != NULL);
12259     }
12260
12261   if (column_list_el->prev == base_el)
12262     return;
12263
12264   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
12265   if (base_el == NULL)
12266     {
12267       column_list_el->prev = NULL;
12268       column_list_el->next = tree_view->priv->columns;
12269       if (column_list_el->next)
12270         column_list_el->next->prev = column_list_el;
12271       tree_view->priv->columns = column_list_el;
12272     }
12273   else
12274     {
12275       column_list_el->prev = base_el;
12276       column_list_el->next = base_el->next;
12277       if (column_list_el->next)
12278         column_list_el->next->prev = column_list_el;
12279       base_el->next = column_list_el;
12280     }
12281
12282   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12283     {
12284       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12285       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
12286     }
12287
12288   _gtk_tree_view_reset_header_styles (tree_view);
12289
12290   _gtk_tree_view_accessible_reorder_column (tree_view, column);
12291
12292   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12293 }
12294
12295 /**
12296  * gtk_tree_view_set_expander_column:
12297  * @tree_view: A #GtkTreeView
12298  * @column: %NULL, or the column to draw the expander arrow at.
12299  *
12300  * Sets the column to draw the expander arrow at. It must be in @tree_view.
12301  * If @column is %NULL, then the expander arrow is always at the first
12302  * visible column.
12303  *
12304  * If you do not want expander arrow to appear in your tree, set the
12305  * expander column to a hidden column.
12306  **/
12307 void
12308 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
12309                                    GtkTreeViewColumn *column)
12310 {
12311   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12312   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12313   g_return_if_fail (column == NULL || gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view));
12314
12315   if (tree_view->priv->expander_column != column)
12316     {
12317       tree_view->priv->expander_column = column;
12318       g_object_notify (G_OBJECT (tree_view), "expander-column");
12319     }
12320 }
12321
12322 /**
12323  * gtk_tree_view_get_expander_column:
12324  * @tree_view: A #GtkTreeView
12325  *
12326  * Returns the column that is the current expander column.
12327  * This column has the expander arrow drawn next to it.
12328  *
12329  * Return value: (transfer none): The expander column.
12330  **/
12331 GtkTreeViewColumn *
12332 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
12333 {
12334   GList *list;
12335
12336   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12337
12338   for (list = tree_view->priv->columns; list; list = list->next)
12339     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
12340       return (GtkTreeViewColumn *) list->data;
12341   return NULL;
12342 }
12343
12344
12345 /**
12346  * gtk_tree_view_set_column_drag_function:
12347  * @tree_view: A #GtkTreeView.
12348  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
12349  * @user_data: (allow-none): User data to be passed to @func, or %NULL
12350  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
12351  *
12352  * Sets a user function for determining where a column may be dropped when
12353  * dragged.  This function is called on every column pair in turn at the
12354  * beginning of a column drag to determine where a drop can take place.  The
12355  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
12356  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
12357  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
12358  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
12359  * @tree_view reverts to the default behavior of allowing all columns to be
12360  * dropped everywhere.
12361  **/
12362 void
12363 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
12364                                         GtkTreeViewColumnDropFunc  func,
12365                                         gpointer                   user_data,
12366                                         GDestroyNotify             destroy)
12367 {
12368   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12369
12370   if (tree_view->priv->column_drop_func_data_destroy)
12371     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
12372
12373   tree_view->priv->column_drop_func = func;
12374   tree_view->priv->column_drop_func_data = user_data;
12375   tree_view->priv->column_drop_func_data_destroy = destroy;
12376 }
12377
12378 /**
12379  * gtk_tree_view_scroll_to_point:
12380  * @tree_view: a #GtkTreeView
12381  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
12382  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
12383  *
12384  * Scrolls the tree view such that the top-left corner of the visible
12385  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
12386  * in tree coordinates.  The @tree_view must be realized before
12387  * this function is called.  If it isn't, you probably want to be
12388  * using gtk_tree_view_scroll_to_cell().
12389  *
12390  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
12391  **/
12392 void
12393 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
12394                                gint         tree_x,
12395                                gint         tree_y)
12396 {
12397   GtkAdjustment *hadj;
12398   GtkAdjustment *vadj;
12399
12400   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12401   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
12402
12403   hadj = tree_view->priv->hadjustment;
12404   vadj = tree_view->priv->vadjustment;
12405
12406   if (tree_x != -1)
12407     gtk_adjustment_set_value (hadj, tree_x);
12408   if (tree_y != -1)
12409     gtk_adjustment_set_value (vadj, tree_y);
12410 }
12411
12412 /**
12413  * gtk_tree_view_scroll_to_cell:
12414  * @tree_view: A #GtkTreeView.
12415  * @path: (allow-none): The path of the row to move to, or %NULL.
12416  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
12417  * @use_align: whether to use alignment arguments, or %FALSE.
12418  * @row_align: The vertical alignment of the row specified by @path.
12419  * @col_align: The horizontal alignment of the column specified by @column.
12420  *
12421  * Moves the alignments of @tree_view to the position specified by @column and
12422  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
12423  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
12424  * or @path need to be non-%NULL.  @row_align determines where the row is
12425  * placed, and @col_align determines where @column is placed.  Both are expected
12426  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
12427  * right/bottom alignment, 0.5 means center.
12428  *
12429  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
12430  * tree does the minimum amount of work to scroll the cell onto the screen.
12431  * This means that the cell will be scrolled to the edge closest to its current
12432  * position.  If the cell is currently visible on the screen, nothing is done.
12433  *
12434  * This function only works if the model is set, and @path is a valid row on the
12435  * model.  If the model changes before the @tree_view is realized, the centered
12436  * path will be modified to reflect this change.
12437  **/
12438 void
12439 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
12440                               GtkTreePath       *path,
12441                               GtkTreeViewColumn *column,
12442                               gboolean           use_align,
12443                               gfloat             row_align,
12444                               gfloat             col_align)
12445 {
12446   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12447   g_return_if_fail (tree_view->priv->model != NULL);
12448   g_return_if_fail (tree_view->priv->tree != NULL);
12449   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
12450   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
12451   g_return_if_fail (path != NULL || column != NULL);
12452
12453 #if 0
12454   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
12455            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
12456 #endif
12457   row_align = CLAMP (row_align, 0.0, 1.0);
12458   col_align = CLAMP (col_align, 0.0, 1.0);
12459
12460
12461   /* Note: Despite the benefits that come from having one code path for the
12462    * scrolling code, we short-circuit validate_visible_area's immplementation as
12463    * it is much slower than just going to the point.
12464    */
12465   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
12466       !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
12467       _gtk_widget_get_alloc_needed (GTK_WIDGET (tree_view)) ||
12468       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
12469     {
12470       if (tree_view->priv->scroll_to_path)
12471         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
12472
12473       tree_view->priv->scroll_to_path = NULL;
12474       tree_view->priv->scroll_to_column = NULL;
12475
12476       if (path)
12477         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
12478       if (column)
12479         tree_view->priv->scroll_to_column = column;
12480       tree_view->priv->scroll_to_use_align = use_align;
12481       tree_view->priv->scroll_to_row_align = row_align;
12482       tree_view->priv->scroll_to_col_align = col_align;
12483
12484       install_presize_handler (tree_view);
12485     }
12486   else
12487     {
12488       GdkRectangle cell_rect;
12489       GdkRectangle vis_rect;
12490       gint dest_x, dest_y;
12491
12492       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
12493       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
12494
12495       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
12496
12497       dest_x = vis_rect.x;
12498       dest_y = vis_rect.y;
12499
12500       if (column)
12501         {
12502           if (use_align)
12503             {
12504               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
12505             }
12506           else
12507             {
12508               if (cell_rect.x < vis_rect.x)
12509                 dest_x = cell_rect.x;
12510               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
12511                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
12512             }
12513         }
12514
12515       if (path)
12516         {
12517           if (use_align)
12518             {
12519               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
12520               dest_y = MAX (dest_y, 0);
12521             }
12522           else
12523             {
12524               if (cell_rect.y < vis_rect.y)
12525                 dest_y = cell_rect.y;
12526               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
12527                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
12528             }
12529         }
12530
12531       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
12532     }
12533 }
12534
12535 /**
12536  * gtk_tree_view_row_activated:
12537  * @tree_view: A #GtkTreeView
12538  * @path: The #GtkTreePath to be activated.
12539  * @column: The #GtkTreeViewColumn to be activated.
12540  *
12541  * Activates the cell determined by @path and @column.
12542  **/
12543 void
12544 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
12545                              GtkTreePath       *path,
12546                              GtkTreeViewColumn *column)
12547 {
12548   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12549
12550   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
12551 }
12552
12553
12554 static void
12555 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
12556                                           GtkRBNode *node,
12557                                           gpointer   data)
12558 {
12559   GtkTreeView *tree_view = data;
12560
12561   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
12562       node->children)
12563     {
12564       GtkTreePath *path;
12565       GtkTreeIter iter;
12566
12567       path = _gtk_tree_path_new_from_rbtree (tree, node);
12568       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12569
12570       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12571
12572       gtk_tree_path_free (path);
12573     }
12574
12575   if (node->children)
12576     _gtk_rbtree_traverse (node->children,
12577                           node->children->root,
12578                           G_PRE_ORDER,
12579                           gtk_tree_view_expand_all_emission_helper,
12580                           tree_view);
12581 }
12582
12583 /**
12584  * gtk_tree_view_expand_all:
12585  * @tree_view: A #GtkTreeView.
12586  *
12587  * Recursively expands all nodes in the @tree_view.
12588  **/
12589 void
12590 gtk_tree_view_expand_all (GtkTreeView *tree_view)
12591 {
12592   GtkTreePath *path;
12593   GtkRBTree *tree;
12594   GtkRBNode *node;
12595
12596   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12597
12598   if (tree_view->priv->tree == NULL)
12599     return;
12600
12601   path = gtk_tree_path_new_first ();
12602   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12603
12604   while (node)
12605     {
12606       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
12607       node = _gtk_rbtree_next (tree, node);
12608       gtk_tree_path_next (path);
12609   }
12610
12611   gtk_tree_path_free (path);
12612 }
12613
12614 /**
12615  * gtk_tree_view_collapse_all:
12616  * @tree_view: A #GtkTreeView.
12617  *
12618  * Recursively collapses all visible, expanded nodes in @tree_view.
12619  **/
12620 void
12621 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
12622 {
12623   GtkRBTree *tree;
12624   GtkRBNode *node;
12625   GtkTreePath *path;
12626   gint *indices;
12627
12628   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12629
12630   if (tree_view->priv->tree == NULL)
12631     return;
12632
12633   path = gtk_tree_path_new ();
12634   gtk_tree_path_down (path);
12635   indices = gtk_tree_path_get_indices (path);
12636
12637   tree = tree_view->priv->tree;
12638   node = _gtk_rbtree_first (tree);
12639
12640   while (node)
12641     {
12642       if (node->children)
12643         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12644       indices[0]++;
12645       node = _gtk_rbtree_next (tree, node);
12646     }
12647
12648   gtk_tree_path_free (path);
12649 }
12650
12651 /**
12652  * gtk_tree_view_expand_to_path:
12653  * @tree_view: A #GtkTreeView.
12654  * @path: path to a row.
12655  *
12656  * Expands the row at @path. This will also expand all parent rows of
12657  * @path as necessary.
12658  *
12659  * Since: 2.2
12660  **/
12661 void
12662 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
12663                               GtkTreePath *path)
12664 {
12665   gint i, depth;
12666   gint *indices;
12667   GtkTreePath *tmp;
12668
12669   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12670   g_return_if_fail (path != NULL);
12671
12672   depth = gtk_tree_path_get_depth (path);
12673   indices = gtk_tree_path_get_indices (path);
12674
12675   tmp = gtk_tree_path_new ();
12676   g_return_if_fail (tmp != NULL);
12677
12678   for (i = 0; i < depth; i++)
12679     {
12680       gtk_tree_path_append_index (tmp, indices[i]);
12681       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12682     }
12683
12684   gtk_tree_path_free (tmp);
12685 }
12686
12687 /* FIXME the bool return values for expand_row and collapse_row are
12688  * not analagous; they should be TRUE if the row had children and
12689  * was not already in the requested state.
12690  */
12691
12692
12693 static gboolean
12694 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12695                                GtkTreePath *path,
12696                                GtkRBTree   *tree,
12697                                GtkRBNode   *node,
12698                                gboolean     open_all,
12699                                gboolean     animate)
12700 {
12701   GtkTreeIter iter;
12702   GtkTreeIter temp;
12703   gboolean expand;
12704
12705   if (animate)
12706     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12707                   "gtk-enable-animations", &animate,
12708                   NULL);
12709
12710   remove_auto_expand_timeout (tree_view);
12711
12712   if (node->children && !open_all)
12713     return FALSE;
12714
12715   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12716     return FALSE;
12717
12718   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12719   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12720     return FALSE;
12721
12722
12723    if (node->children && open_all)
12724     {
12725       gboolean retval = FALSE;
12726       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12727
12728       gtk_tree_path_append_index (tmp_path, 0);
12729       tree = node->children;
12730       node = _gtk_rbtree_first (tree);
12731       /* try to expand the children */
12732       do
12733         {
12734          gboolean t;
12735          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12736                                             TRUE, animate);
12737          if (t)
12738            retval = TRUE;
12739
12740          gtk_tree_path_next (tmp_path);
12741          node = _gtk_rbtree_next (tree, node);
12742        }
12743       while (node != NULL);
12744
12745       gtk_tree_path_free (tmp_path);
12746
12747       return retval;
12748     }
12749
12750   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12751
12752   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12753     return FALSE;
12754
12755   if (expand)
12756     return FALSE;
12757
12758   node->children = _gtk_rbtree_new ();
12759   node->children->parent_tree = tree;
12760   node->children->parent_node = node;
12761
12762   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12763
12764   gtk_tree_view_build_tree (tree_view,
12765                             node->children,
12766                             &temp,
12767                             gtk_tree_path_get_depth (path) + 1,
12768                             open_all);
12769
12770   _gtk_tree_view_accessible_add (tree_view, node->children, NULL);
12771   _gtk_tree_view_accessible_add_state (tree_view,
12772                                        tree, node,
12773                                        GTK_CELL_RENDERER_EXPANDED);
12774
12775   install_presize_handler (tree_view);
12776
12777   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12778   if (open_all && node->children)
12779     {
12780       _gtk_rbtree_traverse (node->children,
12781                             node->children->root,
12782                             G_PRE_ORDER,
12783                             gtk_tree_view_expand_all_emission_helper,
12784                             tree_view);
12785     }
12786   return TRUE;
12787 }
12788
12789
12790 /**
12791  * gtk_tree_view_expand_row:
12792  * @tree_view: a #GtkTreeView
12793  * @path: path to a row
12794  * @open_all: whether to recursively expand, or just expand immediate children
12795  *
12796  * Opens the row so its children are visible.
12797  *
12798  * Return value: %TRUE if the row existed and had children
12799  **/
12800 gboolean
12801 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12802                           GtkTreePath *path,
12803                           gboolean     open_all)
12804 {
12805   GtkRBTree *tree;
12806   GtkRBNode *node;
12807
12808   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12809   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12810   g_return_val_if_fail (path != NULL, FALSE);
12811
12812   if (_gtk_tree_view_find_node (tree_view,
12813                                 path,
12814                                 &tree,
12815                                 &node))
12816     return FALSE;
12817
12818   if (tree != NULL)
12819     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12820   else
12821     return FALSE;
12822 }
12823
12824 static gboolean
12825 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12826                                  GtkTreePath *path,
12827                                  GtkRBTree   *tree,
12828                                  GtkRBNode   *node,
12829                                  gboolean     animate)
12830 {
12831   GtkTreeIter iter;
12832   GtkTreeIter children;
12833   gboolean collapse;
12834   gint x, y;
12835   GList *list;
12836   GdkWindow *child;
12837   gboolean selection_changed, cursor_changed;
12838
12839   if (animate)
12840     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12841                   "gtk-enable-animations", &animate,
12842                   NULL);
12843
12844   remove_auto_expand_timeout (tree_view);
12845
12846   if (node->children == NULL)
12847     return FALSE;
12848   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12849
12850   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12851
12852   if (collapse)
12853     return FALSE;
12854
12855   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12856    * a chance to prelight the correct node below */
12857
12858   if (tree_view->priv->prelight_tree)
12859     {
12860       GtkRBTree *parent_tree;
12861       GtkRBNode *parent_node;
12862
12863       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12864       parent_node = tree_view->priv->prelight_tree->parent_node;
12865       while (parent_tree)
12866         {
12867           if (parent_tree == tree && parent_node == node)
12868             {
12869               ensure_unprelighted (tree_view);
12870               break;
12871             }
12872           parent_node = parent_tree->parent_node;
12873           parent_tree = parent_tree->parent_tree;
12874         }
12875     }
12876
12877   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12878
12879   for (list = tree_view->priv->columns; list; list = list->next)
12880     {
12881       GtkTreeViewColumn *column = list->data;
12882
12883       if (gtk_tree_view_column_get_visible (column) == FALSE)
12884         continue;
12885       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12886         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12887     }
12888
12889   if (tree_view->priv->destroy_count_func)
12890     {
12891       GtkTreePath *child_path;
12892       gint child_count = 0;
12893       child_path = gtk_tree_path_copy (path);
12894       gtk_tree_path_down (child_path);
12895       if (node->children)
12896         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12897       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12898       gtk_tree_path_free (child_path);
12899     }
12900
12901   if (tree_view->priv->cursor_node)
12902     {
12903       cursor_changed = (node->children == tree_view->priv->cursor_tree)
12904                        || _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree);
12905     }
12906   else
12907     cursor_changed = FALSE;
12908
12909   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12910     {
12911       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12912       if (gtk_tree_path_is_ancestor (path, anchor_path))
12913         {
12914           gtk_tree_row_reference_free (tree_view->priv->anchor);
12915           tree_view->priv->anchor = NULL;
12916         }
12917       gtk_tree_path_free (anchor_path);
12918     }
12919
12920   selection_changed = gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children);
12921
12922   /* Stop a pending double click */
12923   tree_view->priv->last_button_x = -1;
12924   tree_view->priv->last_button_y = -1;
12925
12926   _gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
12927   _gtk_tree_view_accessible_remove_state (tree_view,
12928                                           tree, node,
12929                                           GTK_CELL_RENDERER_EXPANDED);
12930
12931   _gtk_rbtree_remove (node->children);
12932
12933   if (cursor_changed)
12934     gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CURSOR_INVALID);
12935   if (selection_changed)
12936     g_signal_emit_by_name (tree_view->priv->selection, "changed");
12937
12938   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12939     {
12940       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12941     }
12942
12943   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12944
12945   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12946     {
12947       /* now that we've collapsed all rows, we want to try to set the prelight
12948        * again. To do this, we fake a motion event and send it to ourselves. */
12949
12950       child = gdk_window_get_device_position (gdk_window_get_parent (tree_view->priv->bin_window),
12951                                               gdk_device_manager_get_client_pointer (
12952                                                 gdk_display_get_device_manager (
12953                                                   gtk_widget_get_display (GTK_WIDGET (tree_view)))),
12954                                               &x, &y, NULL);
12955       if (child == tree_view->priv->bin_window)
12956         {
12957           GdkEventMotion event;
12958           gint child_x, child_y;
12959
12960           gdk_window_get_position (child, &child_x, &child_y);
12961
12962           event.window = tree_view->priv->bin_window;
12963           event.x = x - child_x;
12964           event.y = y - child_y;
12965
12966           /* despite the fact this isn't a real event, I'm almost positive it will
12967            * never trigger a drag event.  maybe_drag is the only function that uses
12968            * more than just event.x and event.y. */
12969           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
12970         }
12971     }
12972
12973   return TRUE;
12974 }
12975
12976 /**
12977  * gtk_tree_view_collapse_row:
12978  * @tree_view: a #GtkTreeView
12979  * @path: path to a row in the @tree_view
12980  *
12981  * Collapses a row (hides its child rows, if they exist).
12982  *
12983  * Return value: %TRUE if the row was collapsed.
12984  **/
12985 gboolean
12986 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
12987                             GtkTreePath *path)
12988 {
12989   GtkRBTree *tree;
12990   GtkRBNode *node;
12991
12992   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12993   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
12994   g_return_val_if_fail (path != NULL, FALSE);
12995
12996   if (_gtk_tree_view_find_node (tree_view,
12997                                 path,
12998                                 &tree,
12999                                 &node))
13000     return FALSE;
13001
13002   if (tree == NULL || node->children == NULL)
13003     return FALSE;
13004
13005   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
13006 }
13007
13008 static void
13009 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
13010                                         GtkRBTree              *tree,
13011                                         GtkTreePath            *path,
13012                                         GtkTreeViewMappingFunc  func,
13013                                         gpointer                user_data)
13014 {
13015   GtkRBNode *node;
13016
13017   if (tree == NULL || tree->root == NULL)
13018     return;
13019
13020   node = _gtk_rbtree_first (tree);
13021
13022   while (node)
13023     {
13024       if (node->children)
13025         {
13026           (* func) (tree_view, path, user_data);
13027           gtk_tree_path_down (path);
13028           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
13029           gtk_tree_path_up (path);
13030         }
13031       gtk_tree_path_next (path);
13032       node = _gtk_rbtree_next (tree, node);
13033     }
13034 }
13035
13036 /**
13037  * gtk_tree_view_map_expanded_rows:
13038  * @tree_view: A #GtkTreeView
13039  * @func: (scope call): A function to be called
13040  * @data: User data to be passed to the function.
13041  *
13042  * Calls @func on all expanded rows.
13043  **/
13044 void
13045 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
13046                                  GtkTreeViewMappingFunc  func,
13047                                  gpointer                user_data)
13048 {
13049   GtkTreePath *path;
13050
13051   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13052   g_return_if_fail (func != NULL);
13053
13054   path = gtk_tree_path_new_first ();
13055
13056   gtk_tree_view_map_expanded_rows_helper (tree_view,
13057                                           tree_view->priv->tree,
13058                                           path, func, user_data);
13059
13060   gtk_tree_path_free (path);
13061 }
13062
13063 /**
13064  * gtk_tree_view_row_expanded:
13065  * @tree_view: A #GtkTreeView.
13066  * @path: A #GtkTreePath to test expansion state.
13067  *
13068  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
13069  *
13070  * Return value: %TRUE if #path is expanded.
13071  **/
13072 gboolean
13073 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
13074                             GtkTreePath *path)
13075 {
13076   GtkRBTree *tree;
13077   GtkRBNode *node;
13078
13079   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13080   g_return_val_if_fail (path != NULL, FALSE);
13081
13082   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13083
13084   if (node == NULL)
13085     return FALSE;
13086
13087   return (node->children != NULL);
13088 }
13089
13090 /**
13091  * gtk_tree_view_get_reorderable:
13092  * @tree_view: a #GtkTreeView
13093  *
13094  * Retrieves whether the user can reorder the tree via drag-and-drop. See
13095  * gtk_tree_view_set_reorderable().
13096  *
13097  * Return value: %TRUE if the tree can be reordered.
13098  **/
13099 gboolean
13100 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
13101 {
13102   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13103
13104   return tree_view->priv->reorderable;
13105 }
13106
13107 /**
13108  * gtk_tree_view_set_reorderable:
13109  * @tree_view: A #GtkTreeView.
13110  * @reorderable: %TRUE, if the tree can be reordered.
13111  *
13112  * This function is a convenience function to allow you to reorder
13113  * models that support the #GtkTreeDragSourceIface and the
13114  * #GtkTreeDragDestIface.  Both #GtkTreeStore and #GtkListStore support
13115  * these.  If @reorderable is %TRUE, then the user can reorder the
13116  * model by dragging and dropping rows. The developer can listen to
13117  * these changes by connecting to the model's row_inserted and
13118  * row_deleted signals. The reordering is implemented by setting up
13119  * the tree view as a drag source and destination. Therefore, drag and
13120  * drop can not be used in a reorderable view for any other purpose.
13121  *
13122  * This function does not give you any degree of control over the order -- any
13123  * reordering is allowed.  If more control is needed, you should probably
13124  * handle drag and drop manually.
13125  **/
13126 void
13127 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
13128                                gboolean     reorderable)
13129 {
13130   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13131
13132   reorderable = reorderable != FALSE;
13133
13134   if (tree_view->priv->reorderable == reorderable)
13135     return;
13136
13137   if (reorderable)
13138     {
13139       const GtkTargetEntry row_targets[] = {
13140         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
13141       };
13142
13143       gtk_tree_view_enable_model_drag_source (tree_view,
13144                                               GDK_BUTTON1_MASK,
13145                                               row_targets,
13146                                               G_N_ELEMENTS (row_targets),
13147                                               GDK_ACTION_MOVE);
13148       gtk_tree_view_enable_model_drag_dest (tree_view,
13149                                             row_targets,
13150                                             G_N_ELEMENTS (row_targets),
13151                                             GDK_ACTION_MOVE);
13152     }
13153   else
13154     {
13155       gtk_tree_view_unset_rows_drag_source (tree_view);
13156       gtk_tree_view_unset_rows_drag_dest (tree_view);
13157     }
13158
13159   tree_view->priv->reorderable = reorderable;
13160
13161   g_object_notify (G_OBJECT (tree_view), "reorderable");
13162 }
13163
13164 static void
13165 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
13166                                GtkTreePath     *path,
13167                                SetCursorFlags   flags)
13168 {
13169   if (!(flags & CURSOR_INVALID) && tree_view->priv->cursor_node)
13170     {
13171       _gtk_tree_view_accessible_remove_state (tree_view,
13172                                               tree_view->priv->cursor_tree,
13173                                               tree_view->priv->cursor_node,
13174                                               GTK_CELL_RENDERER_FOCUSED);
13175       _gtk_tree_view_queue_draw_node (tree_view,
13176                                       tree_view->priv->cursor_tree,
13177                                       tree_view->priv->cursor_node,
13178                                       NULL);
13179     }
13180
13181   /* One cannot set the cursor on a separator.   Also, if
13182    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
13183    * before finding the tree and node belonging to path.  The
13184    * path maps to a non-existing path and we will silently bail out.
13185    * We unset tree and node to avoid further processing.
13186    */
13187   if (path == NULL ||
13188       row_is_separator (tree_view, NULL, path)
13189       || _gtk_tree_view_find_node (tree_view,
13190                                    path,
13191                                    &tree_view->priv->cursor_tree,
13192                                    &tree_view->priv->cursor_node))
13193     {
13194       tree_view->priv->cursor_tree = NULL;
13195       tree_view->priv->cursor_node = NULL;
13196     }
13197
13198   if (tree_view->priv->cursor_node != NULL)
13199     {
13200       GtkRBTree *new_tree = NULL;
13201       GtkRBNode *new_node = NULL;
13202
13203       if ((flags & CLEAR_AND_SELECT) && !tree_view->priv->modify_selection_pressed)
13204         {
13205           GtkTreeSelectMode mode = 0;
13206
13207           if (tree_view->priv->extend_selection_pressed)
13208             mode |= GTK_TREE_SELECT_MODE_EXTEND;
13209
13210           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
13211                                                     tree_view->priv->cursor_node,
13212                                                     tree_view->priv->cursor_tree,
13213                                                     path,
13214                                                     mode,
13215                                                     FALSE);
13216         }
13217
13218       /* We have to re-find tree and node here again, somebody might have
13219        * cleared the node or the whole tree in the GtkTreeSelection::changed
13220        * callback. If the nodes differ we bail out here.
13221        */
13222       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
13223
13224       if (tree_view->priv->cursor_node != new_node)
13225         return;
13226
13227       if (flags & CLAMP_NODE)
13228         {
13229           gtk_tree_view_clamp_node_visible (tree_view,
13230                                             tree_view->priv->cursor_tree,
13231                                             tree_view->priv->cursor_node);
13232           _gtk_tree_view_queue_draw_node (tree_view,
13233                                           tree_view->priv->cursor_tree,
13234                                           tree_view->priv->cursor_node,
13235                                           NULL);
13236         }
13237
13238       _gtk_tree_view_accessible_add_state (tree_view,
13239                                            tree_view->priv->cursor_tree,
13240                                            tree_view->priv->cursor_node,
13241                                            GTK_CELL_RENDERER_FOCUSED);
13242     }
13243
13244   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
13245 }
13246
13247 /**
13248  * gtk_tree_view_get_cursor:
13249  * @tree_view: A #GtkTreeView
13250  * @path: (out) (transfer full) (allow-none): A pointer to be filled with the current cursor path, or %NULL
13251  * @focus_column: (out) (transfer none) (allow-none): A pointer to be filled with the current focus column, or %NULL
13252  *
13253  * Fills in @path and @focus_column with the current path and focus column.  If
13254  * the cursor isn't currently set, then *@path will be %NULL.  If no column
13255  * currently has focus, then *@focus_column will be %NULL.
13256  *
13257  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
13258  * you are done with it.
13259  **/
13260 void
13261 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
13262                           GtkTreePath       **path,
13263                           GtkTreeViewColumn **focus_column)
13264 {
13265   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13266
13267   if (path)
13268     {
13269       if (tree_view->priv->cursor_node)
13270         *path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
13271                                                 tree_view->priv->cursor_node);
13272       else
13273         *path = NULL;
13274     }
13275
13276   if (focus_column)
13277     {
13278       *focus_column = tree_view->priv->focus_column;
13279     }
13280 }
13281
13282 /**
13283  * gtk_tree_view_set_cursor:
13284  * @tree_view: A #GtkTreeView
13285  * @path: A #GtkTreePath
13286  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13287  * @start_editing: %TRUE if the specified cell should start being edited.
13288  *
13289  * Sets the current keyboard focus to be at @path, and selects it.  This is
13290  * useful when you want to focus the user's attention on a particular row.  If
13291  * @focus_column is not %NULL, then focus is given to the column specified by
13292  * it. Additionally, if @focus_column is specified, and @start_editing is
13293  * %TRUE, then editing should be started in the specified cell.
13294  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
13295  * in order to give keyboard focus to the widget.  Please note that editing
13296  * can only happen when the widget is realized.
13297  *
13298  * If @path is invalid for @model, the current cursor (if any) will be unset
13299  * and the function will return without failing.
13300  **/
13301 void
13302 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
13303                           GtkTreePath       *path,
13304                           GtkTreeViewColumn *focus_column,
13305                           gboolean           start_editing)
13306 {
13307   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
13308                                     NULL, start_editing);
13309 }
13310
13311 /**
13312  * gtk_tree_view_set_cursor_on_cell:
13313  * @tree_view: A #GtkTreeView
13314  * @path: A #GtkTreePath
13315  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13316  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
13317  * @start_editing: %TRUE if the specified cell should start being edited.
13318  *
13319  * Sets the current keyboard focus to be at @path, and selects it.  This is
13320  * useful when you want to focus the user's attention on a particular row.  If
13321  * @focus_column is not %NULL, then focus is given to the column specified by
13322  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
13323  * contains 2 or more editable or activatable cells, then focus is given to
13324  * the cell specified by @focus_cell. Additionally, if @focus_column is
13325  * specified, and @start_editing is %TRUE, then editing should be started in
13326  * the specified cell.  This function is often followed by
13327  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
13328  * widget.  Please note that editing can only happen when the widget is
13329  * realized.
13330  *
13331  * If @path is invalid for @model, the current cursor (if any) will be unset
13332  * and the function will return without failing.
13333  *
13334  * Since: 2.2
13335  **/
13336 void
13337 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
13338                                   GtkTreePath       *path,
13339                                   GtkTreeViewColumn *focus_column,
13340                                   GtkCellRenderer   *focus_cell,
13341                                   gboolean           start_editing)
13342 {
13343   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13344   g_return_if_fail (path != NULL);
13345   g_return_if_fail (focus_column == NULL || GTK_IS_TREE_VIEW_COLUMN (focus_column));
13346
13347   if (!tree_view->priv->model)
13348     return;
13349
13350   if (focus_cell)
13351     {
13352       g_return_if_fail (focus_column);
13353       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
13354     }
13355
13356   /* cancel the current editing, if it exists */
13357   if (tree_view->priv->edited_column &&
13358       gtk_cell_area_get_edit_widget
13359       (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column))))
13360     gtk_tree_view_stop_editing (tree_view, TRUE);
13361
13362   gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
13363
13364   if (focus_column &&
13365       gtk_tree_view_column_get_visible (focus_column))
13366     {
13367       GList *list;
13368       gboolean column_in_tree = FALSE;
13369
13370       for (list = tree_view->priv->columns; list; list = list->next)
13371         if (list->data == focus_column)
13372           {
13373             column_in_tree = TRUE;
13374             break;
13375           }
13376       g_return_if_fail (column_in_tree);
13377       _gtk_tree_view_set_focus_column (tree_view, focus_column);
13378       if (focus_cell)
13379         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
13380       if (start_editing)
13381         gtk_tree_view_start_editing (tree_view, path, TRUE);
13382     }
13383 }
13384
13385 /**
13386  * gtk_tree_view_get_bin_window:
13387  * @tree_view: A #GtkTreeView
13388  *
13389  * Returns the window that @tree_view renders to.
13390  * This is used primarily to compare to <literal>event->window</literal>
13391  * to confirm that the event on @tree_view is on the right window.
13392  *
13393  * Return value: (transfer none): A #GdkWindow, or %NULL when @tree_view
13394  *     hasn't been realized yet
13395  **/
13396 GdkWindow *
13397 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
13398 {
13399   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13400
13401   return tree_view->priv->bin_window;
13402 }
13403
13404 /**
13405  * gtk_tree_view_get_path_at_pos:
13406  * @tree_view: A #GtkTreeView.
13407  * @x: The x position to be identified (relative to bin_window).
13408  * @y: The y position to be identified (relative to bin_window).
13409  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
13410  * @column: (out) (transfer none) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
13411  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
13412  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
13413  *
13414  * Finds the path at the point (@x, @y), relative to bin_window coordinates
13415  * (please see gtk_tree_view_get_bin_window()).
13416  * That is, @x and @y are relative to an events coordinates. @x and @y must
13417  * come from an event on the @tree_view only where <literal>event->window ==
13418  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
13419  * things like popup menus. If @path is non-%NULL, then it will be filled
13420  * with the #GtkTreePath at that point.  This path should be freed with
13421  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
13422  * with the column at that point.  @cell_x and @cell_y return the coordinates
13423  * relative to the cell background (i.e. the @background_area passed to
13424  * gtk_cell_renderer_render()).  This function is only meaningful if
13425  * @tree_view is realized.  Therefore this function will always return %FALSE
13426  * if @tree_view is not realized or does not have a model.
13427  *
13428  * For converting widget coordinates (eg. the ones you get from
13429  * GtkWidget::query-tooltip), please see
13430  * gtk_tree_view_convert_widget_to_bin_window_coords().
13431  *
13432  * Return value: %TRUE if a row exists at that coordinate.
13433  **/
13434 gboolean
13435 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
13436                                gint                x,
13437                                gint                y,
13438                                GtkTreePath       **path,
13439                                GtkTreeViewColumn **column,
13440                                gint               *cell_x,
13441                                gint               *cell_y)
13442 {
13443   GtkRBTree *tree;
13444   GtkRBNode *node;
13445   gint y_offset;
13446
13447   g_return_val_if_fail (tree_view != NULL, FALSE);
13448
13449   if (path)
13450     *path = NULL;
13451   if (column)
13452     *column = NULL;
13453
13454   if (tree_view->priv->bin_window == NULL)
13455     return FALSE;
13456
13457   if (tree_view->priv->tree == NULL)
13458     return FALSE;
13459
13460   if (x > gtk_adjustment_get_upper (tree_view->priv->hadjustment))
13461     return FALSE;
13462
13463   if (x < 0 || y < 0)
13464     return FALSE;
13465
13466   if (column || cell_x)
13467     {
13468       GtkTreeViewColumn *tmp_column;
13469       GtkTreeViewColumn *last_column = NULL;
13470       GList *list;
13471       gint remaining_x = x;
13472       gboolean found = FALSE;
13473       gboolean rtl;
13474       gint width;
13475
13476       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
13477       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13478            list;
13479            list = (rtl ? list->prev : list->next))
13480         {
13481           tmp_column = list->data;
13482
13483           if (gtk_tree_view_column_get_visible (tmp_column) == FALSE)
13484             continue;
13485
13486           last_column = tmp_column;
13487           width = gtk_tree_view_column_get_width (tmp_column);
13488           if (remaining_x <= width)
13489             {
13490               found = TRUE;
13491
13492               if (column)
13493                 *column = tmp_column;
13494
13495               if (cell_x)
13496                 *cell_x = remaining_x;
13497
13498               break;
13499             }
13500           remaining_x -= width;
13501         }
13502
13503       /* If found is FALSE and there is a last_column, then it the remainder
13504        * space is in that area
13505        */
13506       if (!found)
13507         {
13508           if (last_column)
13509             {
13510               if (column)
13511                 *column = last_column;
13512
13513               if (cell_x)
13514                 *cell_x = gtk_tree_view_column_get_width (last_column) + remaining_x;
13515             }
13516           else
13517             {
13518               return FALSE;
13519             }
13520         }
13521     }
13522
13523   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
13524                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
13525                                       &tree, &node);
13526
13527   if (tree == NULL)
13528     return FALSE;
13529
13530   if (cell_y)
13531     *cell_y = y_offset;
13532
13533   if (path)
13534     *path = _gtk_tree_path_new_from_rbtree (tree, node);
13535
13536   return TRUE;
13537 }
13538
13539
13540 static inline gint
13541 gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
13542                                     GtkRBNode   *node,
13543                                     gint         vertical_separator)
13544 {
13545   int expander_size = gtk_tree_view_get_expander_size (tree_view);
13546   int height;
13547
13548   /* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
13549    * i.e. just the cells, no spacing.
13550    *
13551    * The cell area height is at least expander_size - vertical_separator.
13552    * For regular nodes, the height is then at least expander_size. We should
13553    * be able to enforce the expander_size minimum here, because this
13554    * function will not be called for irregular (e.g. separator) rows.
13555    */
13556   height = gtk_tree_view_get_row_height (tree_view, node);
13557   if (height < expander_size)
13558     height = expander_size;
13559
13560   return height - vertical_separator;
13561 }
13562
13563 static inline gint
13564 gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
13565                                       GtkRBTree   *tree,
13566                                       GtkRBNode   *node,
13567                                       gint         vertical_separator)
13568 {
13569   int offset;
13570
13571   offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13572   offset += vertical_separator / 2;
13573
13574   return offset;
13575 }
13576
13577 /**
13578  * gtk_tree_view_get_cell_area:
13579  * @tree_view: a #GtkTreeView
13580  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13581  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
13582  * @rect: (out): rectangle to fill with cell rect
13583  *
13584  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13585  * row specified by @path and the column specified by @column.  If @path is
13586  * %NULL, or points to a path not currently displayed, the @y and @height fields
13587  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13588  * fields will be filled with 0.  The sum of all cell rects does not cover the
13589  * entire tree; there are extra pixels in between rows, for example. The
13590  * returned rectangle is equivalent to the @cell_area passed to
13591  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
13592  * realized.
13593  **/
13594 void
13595 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
13596                              GtkTreePath        *path,
13597                              GtkTreeViewColumn  *column,
13598                              GdkRectangle       *rect)
13599 {
13600   GtkRBTree *tree = NULL;
13601   GtkRBNode *node = NULL;
13602   gint vertical_separator;
13603   gint horizontal_separator;
13604
13605   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13606   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13607   g_return_if_fail (rect != NULL);
13608   g_return_if_fail (!column || gtk_tree_view_column_get_tree_view (column) == (GtkWidget *) tree_view);
13609   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
13610
13611   gtk_widget_style_get (GTK_WIDGET (tree_view),
13612                         "vertical-separator", &vertical_separator,
13613                         "horizontal-separator", &horizontal_separator,
13614                         NULL);
13615
13616   rect->x = 0;
13617   rect->y = 0;
13618   rect->width = 0;
13619   rect->height = 0;
13620
13621   if (column)
13622     {
13623       rect->x = gtk_tree_view_column_get_x_offset (column) + horizontal_separator/2;
13624       rect->width = gtk_tree_view_column_get_width (column) - horizontal_separator;
13625     }
13626
13627   if (path)
13628     {
13629       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13630
13631       /* Get vertical coords */
13632       if ((!ret && tree == NULL) || ret)
13633         return;
13634
13635       if (row_is_separator (tree_view, NULL, path))
13636         {
13637           /* There isn't really a "cell area" for separator, so we
13638            * return the y, height values for background area instead.
13639            */
13640           rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13641           rect->height = gtk_tree_view_get_row_height (tree_view, node);
13642         }
13643       else
13644         {
13645           rect->y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
13646                                                           vertical_separator);
13647           rect->height = gtk_tree_view_get_cell_area_height (tree_view, node,
13648                                                              vertical_separator);
13649         }
13650
13651       if (column &&
13652           gtk_tree_view_is_expander_column (tree_view, column))
13653         {
13654           gint depth = gtk_tree_path_get_depth (path);
13655           gboolean rtl;
13656
13657           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13658
13659           if (!rtl)
13660             rect->x += (depth - 1) * tree_view->priv->level_indentation;
13661           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
13662
13663           if (gtk_tree_view_draw_expanders (tree_view))
13664             {
13665               int expander_size = gtk_tree_view_get_expander_size (tree_view);
13666               if (!rtl)
13667                 rect->x += depth * expander_size;
13668               rect->width -= depth * expander_size;
13669             }
13670
13671           rect->width = MAX (rect->width, 0);
13672         }
13673     }
13674 }
13675
13676 static inline gint
13677 gtk_tree_view_get_row_height (GtkTreeView *tree_view,
13678                               GtkRBNode   *node)
13679 {
13680   int expander_size = gtk_tree_view_get_expander_size (tree_view);
13681   int height;
13682
13683   /* The "background" areas of all rows/cells add up to cover the entire tree.
13684    * The background includes all inter-row and inter-cell spacing.
13685    *
13686    * If the row pointed at by node does not have a height set, we default
13687    * to expander_size, which is the minimum height for regular nodes.
13688    * Non-regular nodes (e.g. separators) can have a height set smaller
13689    * than expander_size and should not be overruled here.
13690    */
13691   height = GTK_RBNODE_GET_HEIGHT (node);
13692   if (height <= 0)
13693     height = expander_size;
13694
13695   return height;
13696 }
13697
13698 static inline gint
13699 gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
13700                                 GtkRBTree   *tree,
13701                                 GtkRBNode   *node)
13702 {
13703   int offset;
13704
13705   offset = _gtk_rbtree_node_find_offset (tree, node);
13706
13707   return RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, offset);
13708 }
13709
13710 /**
13711  * gtk_tree_view_get_background_area:
13712  * @tree_view: a #GtkTreeView
13713  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13714  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
13715  * @rect: (out): rectangle to fill with cell background rect
13716  *
13717  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13718  * row specified by @path and the column specified by @column.  If @path is
13719  * %NULL, or points to a node not found in the tree, the @y and @height fields of
13720  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13721  * fields will be filled with 0.  The returned rectangle is equivalent to the
13722  * @background_area passed to gtk_cell_renderer_render().  These background
13723  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
13724  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
13725  * itself, excluding surrounding borders and the tree expander area.
13726  *
13727  **/
13728 void
13729 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
13730                                    GtkTreePath        *path,
13731                                    GtkTreeViewColumn  *column,
13732                                    GdkRectangle       *rect)
13733 {
13734   GtkRBTree *tree = NULL;
13735   GtkRBNode *node = NULL;
13736
13737   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13738   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13739   g_return_if_fail (rect != NULL);
13740
13741   rect->x = 0;
13742   rect->y = 0;
13743   rect->width = 0;
13744   rect->height = 0;
13745
13746   if (path)
13747     {
13748       /* Get vertical coords */
13749
13750       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
13751           tree == NULL)
13752         return;
13753
13754       rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13755       rect->height = gtk_tree_view_get_row_height (tree_view, node);
13756     }
13757
13758   if (column)
13759     {
13760       gint x2 = 0;
13761
13762       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
13763       rect->width = x2 - rect->x;
13764     }
13765 }
13766
13767 /**
13768  * gtk_tree_view_get_visible_rect:
13769  * @tree_view: a #GtkTreeView
13770  * @visible_rect: (out): rectangle to fill
13771  *
13772  * Fills @visible_rect with the currently-visible region of the
13773  * buffer, in tree coordinates. Convert to bin_window coordinates with
13774  * gtk_tree_view_convert_tree_to_bin_window_coords().
13775  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
13776  * scrollable area of the tree.
13777  **/
13778 void
13779 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
13780                                 GdkRectangle *visible_rect)
13781 {
13782   GtkAllocation allocation;
13783   GtkWidget *widget;
13784
13785   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13786
13787   widget = GTK_WIDGET (tree_view);
13788
13789   if (visible_rect)
13790     {
13791       gtk_widget_get_allocation (widget, &allocation);
13792       visible_rect->x = gtk_adjustment_get_value (tree_view->priv->hadjustment);
13793       visible_rect->y = gtk_adjustment_get_value (tree_view->priv->vadjustment);
13794       visible_rect->width = allocation.width;
13795       visible_rect->height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
13796     }
13797 }
13798
13799 /**
13800  * gtk_tree_view_convert_widget_to_tree_coords:
13801  * @tree_view: a #GtkTreeView
13802  * @wx: X coordinate relative to the widget
13803  * @wy: Y coordinate relative to the widget
13804  * @tx: (out): return location for tree X coordinate
13805  * @ty: (out): return location for tree Y coordinate
13806  *
13807  * Converts widget coordinates to coordinates for the
13808  * tree (the full scrollable area of the tree).
13809  *
13810  * Since: 2.12
13811  **/
13812 void
13813 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13814                                              gint         wx,
13815                                              gint         wy,
13816                                              gint        *tx,
13817                                              gint        *ty)
13818 {
13819   gint x, y;
13820
13821   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13822
13823   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13824                                                      wx, wy,
13825                                                      &x, &y);
13826   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13827                                                    x, y,
13828                                                    tx, ty);
13829 }
13830
13831 /**
13832  * gtk_tree_view_convert_tree_to_widget_coords:
13833  * @tree_view: a #GtkTreeView
13834  * @tx: X coordinate relative to the tree
13835  * @ty: Y coordinate relative to the tree
13836  * @wx: (out): return location for widget X coordinate
13837  * @wy: (out): return location for widget Y coordinate
13838  *
13839  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13840  * to widget coordinates.
13841  *
13842  * Since: 2.12
13843  **/
13844 void
13845 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13846                                              gint         tx,
13847                                              gint         ty,
13848                                              gint        *wx,
13849                                              gint        *wy)
13850 {
13851   gint x, y;
13852
13853   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13854
13855   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13856                                                    tx, ty,
13857                                                    &x, &y);
13858   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13859                                                      x, y,
13860                                                      wx, wy);
13861 }
13862
13863 /**
13864  * gtk_tree_view_convert_widget_to_bin_window_coords:
13865  * @tree_view: a #GtkTreeView
13866  * @wx: X coordinate relative to the widget
13867  * @wy: Y coordinate relative to the widget
13868  * @bx: (out): return location for bin_window X coordinate
13869  * @by: (out): return location for bin_window Y coordinate
13870  *
13871  * Converts widget coordinates to coordinates for the bin_window
13872  * (see gtk_tree_view_get_bin_window()).
13873  *
13874  * Since: 2.12
13875  **/
13876 void
13877 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13878                                                    gint         wx,
13879                                                    gint         wy,
13880                                                    gint        *bx,
13881                                                    gint        *by)
13882 {
13883   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13884
13885   if (bx)
13886     *bx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
13887   if (by)
13888     *by = wy - gtk_tree_view_get_effective_header_height (tree_view);
13889 }
13890
13891 /**
13892  * gtk_tree_view_convert_bin_window_to_widget_coords:
13893  * @tree_view: a #GtkTreeView
13894  * @bx: bin_window X coordinate
13895  * @by: bin_window Y coordinate
13896  * @wx: (out): return location for widget X coordinate
13897  * @wy: (out): return location for widget Y coordinate
13898  *
13899  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13900  * to widget relative coordinates.
13901  *
13902  * Since: 2.12
13903  **/
13904 void
13905 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13906                                                    gint         bx,
13907                                                    gint         by,
13908                                                    gint        *wx,
13909                                                    gint        *wy)
13910 {
13911   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13912
13913   if (wx)
13914     *wx = bx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
13915   if (wy)
13916     *wy = by + gtk_tree_view_get_effective_header_height (tree_view);
13917 }
13918
13919 /**
13920  * gtk_tree_view_convert_tree_to_bin_window_coords:
13921  * @tree_view: a #GtkTreeView
13922  * @tx: tree X coordinate
13923  * @ty: tree Y coordinate
13924  * @bx: (out): return location for X coordinate relative to bin_window
13925  * @by: (out): return location for Y coordinate relative to bin_window
13926  *
13927  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13928  * to bin_window coordinates.
13929  *
13930  * Since: 2.12
13931  **/
13932 void
13933 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13934                                                  gint         tx,
13935                                                  gint         ty,
13936                                                  gint        *bx,
13937                                                  gint        *by)
13938 {
13939   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13940
13941   if (bx)
13942     *bx = tx;
13943   if (by)
13944     *by = ty - tree_view->priv->dy;
13945 }
13946
13947 /**
13948  * gtk_tree_view_convert_bin_window_to_tree_coords:
13949  * @tree_view: a #GtkTreeView
13950  * @bx: X coordinate relative to bin_window
13951  * @by: Y coordinate relative to bin_window
13952  * @tx: (out): return location for tree X coordinate
13953  * @ty: (out): return location for tree Y coordinate
13954  *
13955  * Converts bin_window coordinates to coordinates for the
13956  * tree (the full scrollable area of the tree).
13957  *
13958  * Since: 2.12
13959  **/
13960 void
13961 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
13962                                                  gint         bx,
13963                                                  gint         by,
13964                                                  gint        *tx,
13965                                                  gint        *ty)
13966 {
13967   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13968
13969   if (tx)
13970     *tx = bx;
13971   if (ty)
13972     *ty = by + tree_view->priv->dy;
13973 }
13974
13975
13976
13977 /**
13978  * gtk_tree_view_get_visible_range:
13979  * @tree_view: A #GtkTreeView
13980  * @start_path: (out) (allow-none): Return location for start of region,
13981  *              or %NULL.
13982  * @end_path: (out) (allow-none): Return location for end of region, or %NULL.
13983  *
13984  * Sets @start_path and @end_path to be the first and last visible path.
13985  * Note that there may be invisible paths in between.
13986  *
13987  * The paths should be freed with gtk_tree_path_free() after use.
13988  *
13989  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
13990  *
13991  * Since: 2.8
13992  **/
13993 gboolean
13994 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
13995                                  GtkTreePath **start_path,
13996                                  GtkTreePath **end_path)
13997 {
13998   GtkRBTree *tree;
13999   GtkRBNode *node;
14000   gboolean retval;
14001
14002   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14003
14004   if (!tree_view->priv->tree)
14005     return FALSE;
14006
14007   retval = TRUE;
14008
14009   if (start_path)
14010     {
14011       _gtk_rbtree_find_offset (tree_view->priv->tree,
14012                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
14013                                &tree, &node);
14014       if (node)
14015         *start_path = _gtk_tree_path_new_from_rbtree (tree, node);
14016       else
14017         retval = FALSE;
14018     }
14019
14020   if (end_path)
14021     {
14022       gint y;
14023
14024       if (tree_view->priv->height < gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
14025         y = tree_view->priv->height - 1;
14026       else
14027         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1;
14028
14029       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
14030       if (node)
14031         *end_path = _gtk_tree_path_new_from_rbtree (tree, node);
14032       else
14033         retval = FALSE;
14034     }
14035
14036   return retval;
14037 }
14038
14039 /**
14040  * gtk_tree_view_is_blank_at_pos:
14041  * @tree_view: A #GtkTreeView
14042  * @x: The x position to be identified (relative to bin_window)
14043  * @y: The y position to be identified (relative to bin_window)
14044  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
14045  * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
14046  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
14047  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
14048  *
14049  * Determine whether the point (@x, @y) in @tree_view is blank, that is no
14050  * cell content nor an expander arrow is drawn at the location. If so, the
14051  * location can be considered as the background. You might wish to take
14052  * special action on clicks on the background, such as clearing a current
14053  * selection, having a custom context menu or starting rubber banding.
14054  *
14055  * The @x and @y coordinate that are provided must be relative to bin_window
14056  * coordinates.  That is, @x and @y must come from an event on @tree_view
14057  * where <literal>event->window == gtk_tree_view_get_bin_window (<!-- -->)</literal>.
14058  *
14059  * For converting widget coordinates (eg. the ones you get from
14060  * GtkWidget::query-tooltip), please see
14061  * gtk_tree_view_convert_widget_to_bin_window_coords().
14062  *
14063  * The @path, @column, @cell_x and @cell_y arguments will be filled in
14064  * likewise as for gtk_tree_view_get_path_at_pos().  Please see
14065  * gtk_tree_view_get_path_at_pos() for more information.
14066  *
14067  * Return value: %TRUE if the area at the given coordinates is blank,
14068  * %FALSE otherwise.
14069  *
14070  * Since: 3.0
14071  */
14072 gboolean
14073 gtk_tree_view_is_blank_at_pos (GtkTreeView       *tree_view,
14074                                gint                x,
14075                                gint                y,
14076                                GtkTreePath       **path,
14077                                GtkTreeViewColumn **column,
14078                                gint               *cell_x,
14079                                gint               *cell_y)
14080 {
14081   GtkRBTree *tree;
14082   GtkRBNode *node;
14083   GtkTreeIter iter;
14084   GtkTreePath *real_path;
14085   GtkTreeViewColumn *real_column;
14086   GdkRectangle cell_area, background_area;
14087
14088   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14089
14090   if (!gtk_tree_view_get_path_at_pos (tree_view, x, y,
14091                                       &real_path, &real_column,
14092                                       cell_x, cell_y))
14093     /* If there's no path here, it is blank */
14094     return TRUE;
14095
14096   if (path)
14097     *path = real_path;
14098
14099   if (column)
14100     *column = real_column;
14101
14102   gtk_tree_model_get_iter (tree_view->priv->model, &iter, real_path);
14103   _gtk_tree_view_find_node (tree_view, real_path, &tree, &node);
14104
14105   /* Check if there's an expander arrow at (x, y) */
14106   if (real_column == tree_view->priv->expander_column
14107       && gtk_tree_view_draw_expanders (tree_view))
14108     {
14109       gboolean over_arrow;
14110
14111       over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
14112
14113       if (over_arrow)
14114         {
14115           if (!path)
14116             gtk_tree_path_free (real_path);
14117           return FALSE;
14118         }
14119     }
14120
14121   /* Otherwise, have the column see if there's a cell at (x, y) */
14122   gtk_tree_view_column_cell_set_cell_data (real_column,
14123                                            tree_view->priv->model,
14124                                            &iter,
14125                                            GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14126                                            node->children ? TRUE : FALSE);
14127
14128   gtk_tree_view_get_background_area (tree_view, real_path, real_column,
14129                                      &background_area);
14130   gtk_tree_view_get_cell_area (tree_view, real_path, real_column,
14131                                &cell_area);
14132
14133   if (!path)
14134     gtk_tree_path_free (real_path);
14135
14136   return _gtk_tree_view_column_is_blank_at_pos (real_column,
14137                                                 &cell_area,
14138                                                 &background_area,
14139                                                 x, y);
14140 }
14141
14142 static void
14143 unset_reorderable (GtkTreeView *tree_view)
14144 {
14145   if (tree_view->priv->reorderable)
14146     {
14147       tree_view->priv->reorderable = FALSE;
14148       g_object_notify (G_OBJECT (tree_view), "reorderable");
14149     }
14150 }
14151
14152 /**
14153  * gtk_tree_view_enable_model_drag_source:
14154  * @tree_view: a #GtkTreeView
14155  * @start_button_mask: Mask of allowed buttons to start drag
14156  * @targets: (array length=n_targets): the table of targets that the drag will support
14157  * @n_targets: the number of items in @targets
14158  * @actions: the bitmask of possible actions for a drag from this
14159  *    widget
14160  *
14161  * Turns @tree_view into a drag source for automatic DND. Calling this
14162  * method sets #GtkTreeView:reorderable to %FALSE.
14163  **/
14164 void
14165 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
14166                                         GdkModifierType           start_button_mask,
14167                                         const GtkTargetEntry     *targets,
14168                                         gint                      n_targets,
14169                                         GdkDragAction             actions)
14170 {
14171   TreeViewDragInfo *di;
14172
14173   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14174
14175   gtk_drag_source_set (GTK_WIDGET (tree_view),
14176                        0,
14177                        targets,
14178                        n_targets,
14179                        actions);
14180
14181   di = ensure_info (tree_view);
14182
14183   di->start_button_mask = start_button_mask;
14184   di->source_actions = actions;
14185   di->source_set = TRUE;
14186
14187   unset_reorderable (tree_view);
14188 }
14189
14190 /**
14191  * gtk_tree_view_enable_model_drag_dest:
14192  * @tree_view: a #GtkTreeView
14193  * @targets: (array length=n_targets): the table of targets that
14194  *           the drag will support
14195  * @n_targets: the number of items in @targets
14196  * @actions: the bitmask of possible actions for a drag from this
14197  *    widget
14198  *
14199  * Turns @tree_view into a drop destination for automatic DND. Calling
14200  * this method sets #GtkTreeView:reorderable to %FALSE.
14201  **/
14202 void
14203 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
14204                                       const GtkTargetEntry     *targets,
14205                                       gint                      n_targets,
14206                                       GdkDragAction             actions)
14207 {
14208   TreeViewDragInfo *di;
14209
14210   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14211
14212   gtk_drag_dest_set (GTK_WIDGET (tree_view),
14213                      0,
14214                      targets,
14215                      n_targets,
14216                      actions);
14217
14218   di = ensure_info (tree_view);
14219   di->dest_set = TRUE;
14220
14221   unset_reorderable (tree_view);
14222 }
14223
14224 /**
14225  * gtk_tree_view_unset_rows_drag_source:
14226  * @tree_view: a #GtkTreeView
14227  *
14228  * Undoes the effect of
14229  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
14230  * #GtkTreeView:reorderable to %FALSE.
14231  **/
14232 void
14233 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
14234 {
14235   TreeViewDragInfo *di;
14236
14237   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14238
14239   di = get_info (tree_view);
14240
14241   if (di)
14242     {
14243       if (di->source_set)
14244         {
14245           gtk_drag_source_unset (GTK_WIDGET (tree_view));
14246           di->source_set = FALSE;
14247         }
14248
14249       if (!di->dest_set && !di->source_set)
14250         remove_info (tree_view);
14251     }
14252
14253   unset_reorderable (tree_view);
14254 }
14255
14256 /**
14257  * gtk_tree_view_unset_rows_drag_dest:
14258  * @tree_view: a #GtkTreeView
14259  *
14260  * Undoes the effect of
14261  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
14262  * #GtkTreeView:reorderable to %FALSE.
14263  **/
14264 void
14265 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
14266 {
14267   TreeViewDragInfo *di;
14268
14269   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14270
14271   di = get_info (tree_view);
14272
14273   if (di)
14274     {
14275       if (di->dest_set)
14276         {
14277           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
14278           di->dest_set = FALSE;
14279         }
14280
14281       if (!di->dest_set && !di->source_set)
14282         remove_info (tree_view);
14283     }
14284
14285   unset_reorderable (tree_view);
14286 }
14287
14288 /**
14289  * gtk_tree_view_set_drag_dest_row:
14290  * @tree_view: a #GtkTreeView
14291  * @path: (allow-none): The path of the row to highlight, or %NULL
14292  * @pos: Specifies whether to drop before, after or into the row
14293  *
14294  * Sets the row that is highlighted for feedback.
14295  * If @path is %NULL, an existing highlight is removed.
14296  */
14297 void
14298 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
14299                                  GtkTreePath            *path,
14300                                  GtkTreeViewDropPosition pos)
14301 {
14302   GtkTreePath *current_dest;
14303
14304   /* Note; this function is exported to allow a custom DND
14305    * implementation, so it can't touch TreeViewDragInfo
14306    */
14307
14308   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14309
14310   current_dest = NULL;
14311
14312   if (tree_view->priv->drag_dest_row)
14313     {
14314       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14315       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
14316     }
14317
14318   /* special case a drop on an empty model */
14319   tree_view->priv->empty_view_drop = 0;
14320
14321   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
14322       && gtk_tree_path_get_depth (path) == 1
14323       && gtk_tree_path_get_indices (path)[0] == 0)
14324     {
14325       gint n_children;
14326
14327       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
14328                                                    NULL);
14329
14330       if (!n_children)
14331         tree_view->priv->empty_view_drop = 1;
14332     }
14333
14334   tree_view->priv->drag_dest_pos = pos;
14335
14336   if (path)
14337     {
14338       tree_view->priv->drag_dest_row =
14339         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
14340       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
14341     }
14342   else
14343     tree_view->priv->drag_dest_row = NULL;
14344
14345   if (current_dest)
14346     {
14347       GtkRBTree *tree, *new_tree;
14348       GtkRBNode *node, *new_node;
14349
14350       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
14351       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
14352
14353       if (tree && node)
14354         {
14355           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
14356           if (new_tree && new_node)
14357             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14358
14359           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
14360           if (new_tree && new_node)
14361             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14362         }
14363       gtk_tree_path_free (current_dest);
14364     }
14365 }
14366
14367 /**
14368  * gtk_tree_view_get_drag_dest_row:
14369  * @tree_view: a #GtkTreeView
14370  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14371  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14372  *
14373  * Gets information about the row that is highlighted for feedback.
14374  **/
14375 void
14376 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
14377                                  GtkTreePath             **path,
14378                                  GtkTreeViewDropPosition  *pos)
14379 {
14380   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14381
14382   if (path)
14383     {
14384       if (tree_view->priv->drag_dest_row)
14385         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14386       else
14387         {
14388           if (tree_view->priv->empty_view_drop)
14389             *path = gtk_tree_path_new_from_indices (0, -1);
14390           else
14391             *path = NULL;
14392         }
14393     }
14394
14395   if (pos)
14396     *pos = tree_view->priv->drag_dest_pos;
14397 }
14398
14399 /**
14400  * gtk_tree_view_get_dest_row_at_pos:
14401  * @tree_view: a #GtkTreeView
14402  * @drag_x: the position to determine the destination row for
14403  * @drag_y: the position to determine the destination row for
14404  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14405  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14406  *
14407  * Determines the destination row for a given position.  @drag_x and
14408  * @drag_y are expected to be in widget coordinates.  This function is only
14409  * meaningful if @tree_view is realized.  Therefore this function will always
14410  * return %FALSE if @tree_view is not realized or does not have a model.
14411  *
14412  * Return value: whether there is a row at the given position, %TRUE if this
14413  * is indeed the case.
14414  **/
14415 gboolean
14416 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
14417                                    gint                     drag_x,
14418                                    gint                     drag_y,
14419                                    GtkTreePath            **path,
14420                                    GtkTreeViewDropPosition *pos)
14421 {
14422   gint cell_y;
14423   gint bin_x, bin_y;
14424   gdouble offset_into_row;
14425   gdouble third;
14426   GdkRectangle cell;
14427   GtkTreeViewColumn *column = NULL;
14428   GtkTreePath *tmp_path = NULL;
14429
14430   /* Note; this function is exported to allow a custom DND
14431    * implementation, so it can't touch TreeViewDragInfo
14432    */
14433
14434   g_return_val_if_fail (tree_view != NULL, FALSE);
14435   g_return_val_if_fail (drag_x >= 0, FALSE);
14436   g_return_val_if_fail (drag_y >= 0, FALSE);
14437
14438   if (path)
14439     *path = NULL;
14440
14441   if (tree_view->priv->bin_window == NULL)
14442     return FALSE;
14443
14444   if (tree_view->priv->tree == NULL)
14445     return FALSE;
14446
14447   /* If in the top third of a row, we drop before that row; if
14448    * in the bottom third, drop after that row; if in the middle,
14449    * and the row has children, drop into the row.
14450    */
14451   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
14452                                                      &bin_x, &bin_y);
14453
14454   if (!gtk_tree_view_get_path_at_pos (tree_view,
14455                                       bin_x,
14456                                       bin_y,
14457                                       &tmp_path,
14458                                       &column,
14459                                       NULL,
14460                                       &cell_y))
14461     return FALSE;
14462
14463   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
14464                                      &cell);
14465
14466   offset_into_row = cell_y;
14467
14468   if (path)
14469     *path = tmp_path;
14470   else
14471     gtk_tree_path_free (tmp_path);
14472
14473   tmp_path = NULL;
14474
14475   third = cell.height / 3.0;
14476
14477   if (pos)
14478     {
14479       if (offset_into_row < third)
14480         {
14481           *pos = GTK_TREE_VIEW_DROP_BEFORE;
14482         }
14483       else if (offset_into_row < (cell.height / 2.0))
14484         {
14485           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
14486         }
14487       else if (offset_into_row < third * 2.0)
14488         {
14489           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
14490         }
14491       else
14492         {
14493           *pos = GTK_TREE_VIEW_DROP_AFTER;
14494         }
14495     }
14496
14497   return TRUE;
14498 }
14499
14500
14501
14502 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
14503 /**
14504  * gtk_tree_view_create_row_drag_icon:
14505  * @tree_view: a #GtkTreeView
14506  * @path: a #GtkTreePath in @tree_view
14507  *
14508  * Creates a #cairo_surface_t representation of the row at @path.
14509  * This image is used for a drag icon.
14510  *
14511  * Return value: (transfer full): a newly-allocated surface of the drag icon.
14512  **/
14513 cairo_surface_t *
14514 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
14515                                     GtkTreePath  *path)
14516 {
14517   GtkTreeIter   iter;
14518   GtkRBTree    *tree;
14519   GtkRBNode    *node;
14520   GtkStyleContext *context;
14521   gint cell_offset;
14522   GList *list;
14523   GdkRectangle background_area;
14524   GtkWidget *widget;
14525   gint depth;
14526   /* start drawing inside the black outline */
14527   gint x = 1, y = 1;
14528   cairo_surface_t *surface;
14529   gint bin_window_width;
14530   gboolean is_separator = FALSE;
14531   gboolean rtl, allow_rules;
14532   cairo_t *cr;
14533
14534   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14535   g_return_val_if_fail (path != NULL, NULL);
14536
14537   widget = GTK_WIDGET (tree_view);
14538
14539   if (!gtk_widget_get_realized (widget))
14540     return NULL;
14541
14542   depth = gtk_tree_path_get_depth (path);
14543
14544   _gtk_tree_view_find_node (tree_view,
14545                             path,
14546                             &tree,
14547                             &node);
14548
14549   if (tree == NULL)
14550     return NULL;
14551
14552   if (!gtk_tree_model_get_iter (tree_view->priv->model,
14553                                 &iter,
14554                                 path))
14555     return NULL;
14556
14557   context = gtk_widget_get_style_context (widget);
14558
14559   gtk_style_context_save (context);
14560
14561   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
14562   gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0);
14563
14564   gtk_widget_style_get (widget,
14565                         "allow-rules", &allow_rules,
14566                         NULL);
14567
14568   if (allow_rules && tree_view->priv->has_rules)
14569     {
14570       GtkRegionFlags row_flags;
14571
14572       if ((_gtk_rbtree_node_get_index (tree, node) % 2))
14573         row_flags = GTK_REGION_ODD;
14574       else
14575         row_flags = GTK_REGION_EVEN;
14576
14577       gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
14578     }
14579
14580   is_separator = row_is_separator (tree_view, &iter, NULL);
14581
14582   cell_offset = x;
14583
14584   background_area.y = y;
14585   background_area.height = gtk_tree_view_get_row_height (tree_view, node);
14586
14587   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
14588
14589   surface = gdk_window_create_similar_surface (tree_view->priv->bin_window,
14590                                                CAIRO_CONTENT_COLOR,
14591                                                bin_window_width + 2,
14592                                                background_area.height + 2);
14593
14594   cr = cairo_create (surface);
14595
14596   gtk_render_background (context, cr, 0, 0,
14597                          bin_window_width + 2,
14598                          background_area.height + 2);
14599
14600   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
14601
14602   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
14603       list;
14604       list = (rtl ? list->prev : list->next))
14605     {
14606       GtkTreeViewColumn *column = list->data;
14607       GdkRectangle cell_area;
14608       gint vertical_separator;
14609
14610       if (!gtk_tree_view_column_get_visible (column))
14611         continue;
14612
14613       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
14614                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14615                                                node->children?TRUE:FALSE);
14616
14617       background_area.x = cell_offset;
14618       background_area.width = gtk_tree_view_column_get_width (column);
14619
14620       gtk_widget_style_get (widget,
14621                             "vertical-separator", &vertical_separator,
14622                             NULL);
14623
14624       cell_area = background_area;
14625
14626       cell_area.y += vertical_separator / 2;
14627       cell_area.height -= vertical_separator;
14628
14629       if (gtk_tree_view_is_expander_column (tree_view, column))
14630         {
14631           if (!rtl)
14632             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
14633           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
14634
14635           if (gtk_tree_view_draw_expanders (tree_view))
14636             {
14637               int expander_size = gtk_tree_view_get_expander_size (tree_view);
14638               if (!rtl)
14639                 cell_area.x += depth * expander_size;
14640               cell_area.width -= depth * expander_size;
14641             }
14642         }
14643
14644       if (gtk_tree_view_column_cell_is_visible (column))
14645         {
14646           if (is_separator)
14647             {
14648               gtk_style_context_save (context);
14649               gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
14650
14651               gtk_render_line (context, cr,
14652                                cell_area.x,
14653                                cell_area.y + cell_area.height / 2,
14654                                cell_area.x + cell_area.width,
14655                                cell_area.y + cell_area.height / 2);
14656
14657               gtk_style_context_restore (context);
14658             }
14659           else
14660             {
14661               _gtk_tree_view_column_cell_render (column,
14662                                                  cr,
14663                                                  &background_area,
14664                                                  &cell_area,
14665                                                  0, FALSE);
14666             }
14667         }
14668       cell_offset += gtk_tree_view_column_get_width (column);
14669     }
14670
14671   cairo_set_source_rgb (cr, 0, 0, 0);
14672   cairo_rectangle (cr,
14673                    0.5, 0.5,
14674                    bin_window_width + 1,
14675                    background_area.height + 1);
14676   cairo_set_line_width (cr, 1.0);
14677   cairo_stroke (cr);
14678
14679   cairo_destroy (cr);
14680
14681   cairo_surface_set_device_offset (surface, 2, 2);
14682
14683   gtk_style_context_restore (context);
14684
14685   return surface;
14686 }
14687
14688
14689 /**
14690  * gtk_tree_view_set_destroy_count_func:
14691  * @tree_view: A #GtkTreeView
14692  * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
14693  * @data: (allow-none): User data to be passed to @func, or %NULL
14694  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14695  *
14696  * This function should almost never be used.  It is meant for private use by
14697  * ATK for determining the number of visible children that are removed when the
14698  * user collapses a row, or a row is deleted.
14699  *
14700  * Deprecated: 3.4: Accessibility does not need the function anymore.
14701  **/
14702 void
14703 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
14704                                       GtkTreeDestroyCountFunc  func,
14705                                       gpointer                 data,
14706                                       GDestroyNotify           destroy)
14707 {
14708   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14709
14710   if (tree_view->priv->destroy_count_destroy)
14711     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
14712
14713   tree_view->priv->destroy_count_func = func;
14714   tree_view->priv->destroy_count_data = data;
14715   tree_view->priv->destroy_count_destroy = destroy;
14716 }
14717
14718
14719 /*
14720  * Interactive search
14721  */
14722
14723 /**
14724  * gtk_tree_view_set_enable_search:
14725  * @tree_view: A #GtkTreeView
14726  * @enable_search: %TRUE, if the user can search interactively
14727  *
14728  * If @enable_search is set, then the user can type in text to search through
14729  * the tree interactively (this is sometimes called "typeahead find").
14730  *
14731  * Note that even if this is %FALSE, the user can still initiate a search
14732  * using the "start-interactive-search" key binding.
14733  */
14734 void
14735 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
14736                                  gboolean     enable_search)
14737 {
14738   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14739
14740   enable_search = !!enable_search;
14741
14742   if (tree_view->priv->enable_search != enable_search)
14743     {
14744        tree_view->priv->enable_search = enable_search;
14745        g_object_notify (G_OBJECT (tree_view), "enable-search");
14746     }
14747 }
14748
14749 /**
14750  * gtk_tree_view_get_enable_search:
14751  * @tree_view: A #GtkTreeView
14752  *
14753  * Returns whether or not the tree allows to start interactive searching
14754  * by typing in text.
14755  *
14756  * Return value: whether or not to let the user search interactively
14757  */
14758 gboolean
14759 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
14760 {
14761   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14762
14763   return tree_view->priv->enable_search;
14764 }
14765
14766
14767 /**
14768  * gtk_tree_view_get_search_column:
14769  * @tree_view: A #GtkTreeView
14770  *
14771  * Gets the column searched on by the interactive search code.
14772  *
14773  * Return value: the column the interactive search code searches in.
14774  */
14775 gint
14776 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
14777 {
14778   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
14779
14780   return (tree_view->priv->search_column);
14781 }
14782
14783 /**
14784  * gtk_tree_view_set_search_column:
14785  * @tree_view: A #GtkTreeView
14786  * @column: the column of the model to search in, or -1 to disable searching
14787  *
14788  * Sets @column as the column where the interactive search code should
14789  * search in for the current model.
14790  *
14791  * If the search column is set, users can use the "start-interactive-search"
14792  * key binding to bring up search popup. The enable-search property controls
14793  * whether simply typing text will also start an interactive search.
14794  *
14795  * Note that @column refers to a column of the current model. The search
14796  * column is reset to -1 when the model is changed.
14797  */
14798 void
14799 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
14800                                  gint         column)
14801 {
14802   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14803   g_return_if_fail (column >= -1);
14804
14805   if (tree_view->priv->search_column == column)
14806     return;
14807
14808   tree_view->priv->search_column = column;
14809   g_object_notify (G_OBJECT (tree_view), "search-column");
14810 }
14811
14812 /**
14813  * gtk_tree_view_get_search_equal_func: (skip)
14814  * @tree_view: A #GtkTreeView
14815  *
14816  * Returns the compare function currently in use.
14817  *
14818  * Return value: the currently used compare function for the search code.
14819  */
14820
14821 GtkTreeViewSearchEqualFunc
14822 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
14823 {
14824   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14825
14826   return tree_view->priv->search_equal_func;
14827 }
14828
14829 /**
14830  * gtk_tree_view_set_search_equal_func:
14831  * @tree_view: A #GtkTreeView
14832  * @search_equal_func: the compare function to use during the search
14833  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
14834  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
14835  *
14836  * Sets the compare function for the interactive search capabilities; note
14837  * that somewhat like strcmp() returning 0 for equality
14838  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
14839  **/
14840 void
14841 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14842                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14843                                      gpointer                    search_user_data,
14844                                      GDestroyNotify              search_destroy)
14845 {
14846   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14847   g_return_if_fail (search_equal_func != NULL);
14848
14849   if (tree_view->priv->search_destroy)
14850     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14851
14852   tree_view->priv->search_equal_func = search_equal_func;
14853   tree_view->priv->search_user_data = search_user_data;
14854   tree_view->priv->search_destroy = search_destroy;
14855   if (tree_view->priv->search_equal_func == NULL)
14856     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14857 }
14858
14859 /**
14860  * gtk_tree_view_get_search_entry:
14861  * @tree_view: A #GtkTreeView
14862  *
14863  * Returns the #GtkEntry which is currently in use as interactive search
14864  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14865  * will be returned.
14866  *
14867  * Return value: (transfer none): the entry currently in use as search entry.
14868  *
14869  * Since: 2.10
14870  */
14871 GtkEntry *
14872 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14873 {
14874   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14875
14876   if (tree_view->priv->search_custom_entry_set)
14877     return GTK_ENTRY (tree_view->priv->search_entry);
14878
14879   return NULL;
14880 }
14881
14882 /**
14883  * gtk_tree_view_set_search_entry:
14884  * @tree_view: A #GtkTreeView
14885  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
14886  *
14887  * Sets the entry which the interactive search code will use for this
14888  * @tree_view.  This is useful when you want to provide a search entry
14889  * in our interface at all time at a fixed position.  Passing %NULL for
14890  * @entry will make the interactive search code use the built-in popup
14891  * entry again.
14892  *
14893  * Since: 2.10
14894  */
14895 void
14896 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14897                                 GtkEntry    *entry)
14898 {
14899   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14900   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14901
14902   if (tree_view->priv->search_custom_entry_set)
14903     {
14904       if (tree_view->priv->search_entry_changed_id)
14905         {
14906           g_signal_handler_disconnect (tree_view->priv->search_entry,
14907                                        tree_view->priv->search_entry_changed_id);
14908           tree_view->priv->search_entry_changed_id = 0;
14909         }
14910       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14911                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14912                                             tree_view);
14913
14914       g_object_unref (tree_view->priv->search_entry);
14915     }
14916   else if (tree_view->priv->search_window)
14917     {
14918       gtk_widget_destroy (tree_view->priv->search_window);
14919
14920       tree_view->priv->search_window = NULL;
14921     }
14922
14923   if (entry)
14924     {
14925       tree_view->priv->search_entry = g_object_ref (entry);
14926       tree_view->priv->search_custom_entry_set = TRUE;
14927
14928       if (tree_view->priv->search_entry_changed_id == 0)
14929         {
14930           tree_view->priv->search_entry_changed_id =
14931             g_signal_connect (tree_view->priv->search_entry, "changed",
14932                               G_CALLBACK (gtk_tree_view_search_init),
14933                               tree_view);
14934         }
14935
14936         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14937                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14938                           tree_view);
14939
14940         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14941     }
14942   else
14943     {
14944       tree_view->priv->search_entry = NULL;
14945       tree_view->priv->search_custom_entry_set = FALSE;
14946     }
14947 }
14948
14949 /**
14950  * gtk_tree_view_set_search_position_func:
14951  * @tree_view: A #GtkTreeView
14952  * @func: (allow-none): the function to use to position the search dialog, or %NULL
14953  *    to use the default search position function
14954  * @data: (allow-none): user data to pass to @func, or %NULL
14955  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14956  *
14957  * Sets the function to use when positioning the search dialog.
14958  *
14959  * Since: 2.10
14960  **/
14961 void
14962 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
14963                                         GtkTreeViewSearchPositionFunc  func,
14964                                         gpointer                       user_data,
14965                                         GDestroyNotify                 destroy)
14966 {
14967   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14968
14969   if (tree_view->priv->search_position_destroy)
14970     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
14971
14972   tree_view->priv->search_position_func = func;
14973   tree_view->priv->search_position_user_data = user_data;
14974   tree_view->priv->search_position_destroy = destroy;
14975   if (tree_view->priv->search_position_func == NULL)
14976     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
14977 }
14978
14979 /**
14980  * gtk_tree_view_get_search_position_func: (skip)
14981  * @tree_view: A #GtkTreeView
14982  *
14983  * Returns the positioning function currently in use.
14984  *
14985  * Return value: the currently used function for positioning the search dialog.
14986  *
14987  * Since: 2.10
14988  */
14989 GtkTreeViewSearchPositionFunc
14990 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
14991 {
14992   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14993
14994   return tree_view->priv->search_position_func;
14995 }
14996
14997
14998 static void
14999 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
15000                                   GtkTreeView *tree_view,
15001                                   GdkDevice   *device)
15002 {
15003   if (tree_view->priv->disable_popdown)
15004     return;
15005
15006   if (tree_view->priv->search_entry_changed_id)
15007     {
15008       g_signal_handler_disconnect (tree_view->priv->search_entry,
15009                                    tree_view->priv->search_entry_changed_id);
15010       tree_view->priv->search_entry_changed_id = 0;
15011     }
15012   if (tree_view->priv->typeselect_flush_timeout)
15013     {
15014       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15015       tree_view->priv->typeselect_flush_timeout = 0;
15016     }
15017
15018   if (gtk_widget_get_visible (search_dialog))
15019     {
15020       /* send focus-in event */
15021       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
15022       gtk_widget_hide (search_dialog);
15023       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
15024       send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
15025     }
15026 }
15027
15028 static void
15029 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
15030                                     GtkWidget   *search_dialog,
15031                                     gpointer     user_data)
15032 {
15033   gint x, y;
15034   gint tree_x, tree_y;
15035   gint tree_width, tree_height;
15036   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
15037   GdkScreen *screen = gdk_window_get_screen (tree_window);
15038   GtkRequisition requisition;
15039   gint monitor_num;
15040   GdkRectangle monitor;
15041
15042   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
15043   gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
15044
15045   gtk_widget_realize (search_dialog);
15046
15047   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
15048   tree_width = gdk_window_get_width (tree_window);
15049   tree_height = gdk_window_get_height (tree_window);
15050   gtk_widget_get_preferred_size (search_dialog, &requisition, NULL);
15051
15052   if (tree_x + tree_width > gdk_screen_get_width (screen))
15053     x = gdk_screen_get_width (screen) - requisition.width;
15054   else if (tree_x + tree_width - requisition.width < 0)
15055     x = 0;
15056   else
15057     x = tree_x + tree_width - requisition.width;
15058
15059   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
15060     y = gdk_screen_get_height (screen) - requisition.height;
15061   else if (tree_y + tree_height < 0) /* isn't really possible ... */
15062     y = 0;
15063   else
15064     y = tree_y + tree_height;
15065
15066   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
15067 }
15068
15069 static void
15070 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
15071                                       GtkMenu  *menu,
15072                                       gpointer  data)
15073 {
15074   GtkTreeView *tree_view = (GtkTreeView *)data;
15075
15076   tree_view->priv->disable_popdown = 1;
15077   g_signal_connect (menu, "hide",
15078                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
15079 }
15080
15081 /* Because we're visible but offscreen, we just set a flag in the preedit
15082  * callback.
15083  */
15084 static void
15085 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
15086                                       GtkTreeView  *tree_view)
15087 {
15088   tree_view->priv->imcontext_changed = 1;
15089   if (tree_view->priv->typeselect_flush_timeout)
15090     {
15091       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15092       tree_view->priv->typeselect_flush_timeout =
15093         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15094                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15095                        tree_view);
15096     }
15097
15098 }
15099
15100 static void
15101 gtk_tree_view_search_activate (GtkEntry    *entry,
15102                                GtkTreeView *tree_view)
15103 {
15104   GtkTreePath *path;
15105
15106   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
15107                                     tree_view,
15108                                     gtk_get_current_event_device ());
15109
15110   /* If we have a row selected and it's the cursor row, we activate
15111    * the row XXX */
15112   if (tree_view->priv->cursor_node &&
15113       GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
15114     {
15115       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
15116                                              tree_view->priv->cursor_node);
15117
15118       gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
15119
15120       gtk_tree_path_free (path);
15121     }
15122 }
15123
15124 static gboolean
15125 gtk_tree_view_real_search_enable_popdown (gpointer data)
15126 {
15127   GtkTreeView *tree_view = (GtkTreeView *)data;
15128
15129   tree_view->priv->disable_popdown = 0;
15130
15131   return FALSE;
15132 }
15133
15134 static void
15135 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
15136                                      gpointer   data)
15137 {
15138   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
15139 }
15140
15141 static gboolean
15142 gtk_tree_view_search_delete_event (GtkWidget *widget,
15143                                    GdkEventAny *event,
15144                                    GtkTreeView *tree_view)
15145 {
15146   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15147
15148   gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
15149
15150   return TRUE;
15151 }
15152
15153 static gboolean
15154 gtk_tree_view_search_button_press_event (GtkWidget *widget,
15155                                          GdkEventButton *event,
15156                                          GtkTreeView *tree_view)
15157 {
15158   GdkDevice *keyb_device;
15159
15160   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15161
15162   keyb_device = gdk_device_get_associated_device (event->device);
15163   gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
15164
15165   if (event->window == tree_view->priv->bin_window)
15166     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
15167
15168   return TRUE;
15169 }
15170
15171 static gboolean
15172 gtk_tree_view_search_scroll_event (GtkWidget *widget,
15173                                    GdkEventScroll *event,
15174                                    GtkTreeView *tree_view)
15175 {
15176   gboolean retval = FALSE;
15177
15178   if (event->direction == GDK_SCROLL_UP)
15179     {
15180       gtk_tree_view_search_move (widget, tree_view, TRUE);
15181       retval = TRUE;
15182     }
15183   else if (event->direction == GDK_SCROLL_DOWN)
15184     {
15185       gtk_tree_view_search_move (widget, tree_view, FALSE);
15186       retval = TRUE;
15187     }
15188
15189   /* renew the flush timeout */
15190   if (retval && tree_view->priv->typeselect_flush_timeout
15191       && !tree_view->priv->search_custom_entry_set)
15192     {
15193       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15194       tree_view->priv->typeselect_flush_timeout =
15195         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15196                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15197                        tree_view);
15198     }
15199
15200   return retval;
15201 }
15202
15203 static gboolean
15204 gtk_tree_view_search_key_press_event (GtkWidget *widget,
15205                                       GdkEventKey *event,
15206                                       GtkTreeView *tree_view)
15207 {
15208   GdkModifierType default_accel;
15209   gboolean        retval = FALSE;
15210
15211   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15212   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15213
15214   /* close window and cancel the search */
15215   if (!tree_view->priv->search_custom_entry_set
15216       && (event->keyval == GDK_KEY_Escape ||
15217           event->keyval == GDK_KEY_Tab ||
15218             event->keyval == GDK_KEY_KP_Tab ||
15219             event->keyval == GDK_KEY_ISO_Left_Tab))
15220     {
15221       gtk_tree_view_search_dialog_hide (widget, tree_view,
15222                                         gdk_event_get_device ((GdkEvent *) event));
15223       return TRUE;
15224     }
15225
15226   default_accel = gtk_widget_get_modifier_mask (widget,
15227                                                 GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
15228
15229   /* select previous matching iter */
15230   if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
15231     {
15232       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15233         gtk_widget_error_bell (widget);
15234
15235       retval = TRUE;
15236     }
15237
15238   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == (default_accel | GDK_SHIFT_MASK))
15239       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15240     {
15241       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15242         gtk_widget_error_bell (widget);
15243
15244       retval = TRUE;
15245     }
15246
15247   /* select next matching iter */
15248   if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
15249     {
15250       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15251         gtk_widget_error_bell (widget);
15252
15253       retval = TRUE;
15254     }
15255
15256   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == default_accel)
15257       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15258     {
15259       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15260         gtk_widget_error_bell (widget);
15261
15262       retval = TRUE;
15263     }
15264
15265   /* renew the flush timeout */
15266   if (retval && tree_view->priv->typeselect_flush_timeout
15267       && !tree_view->priv->search_custom_entry_set)
15268     {
15269       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15270       tree_view->priv->typeselect_flush_timeout =
15271         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15272                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15273                        tree_view);
15274     }
15275
15276   return retval;
15277 }
15278
15279 /*  this function returns FALSE if there is a search string but
15280  *  nothing was found, and TRUE otherwise.
15281  */
15282 static gboolean
15283 gtk_tree_view_search_move (GtkWidget   *window,
15284                            GtkTreeView *tree_view,
15285                            gboolean     up)
15286 {
15287   gboolean ret;
15288   gint len;
15289   gint count = 0;
15290   const gchar *text;
15291   GtkTreeIter iter;
15292   GtkTreeModel *model;
15293   GtkTreeSelection *selection;
15294
15295   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
15296
15297   g_return_val_if_fail (text != NULL, FALSE);
15298
15299   len = strlen (text);
15300
15301   if (up && tree_view->priv->selected_iter == 1)
15302     return strlen (text) < 1;
15303
15304   len = strlen (text);
15305
15306   if (len < 1)
15307     return TRUE;
15308
15309   model = gtk_tree_view_get_model (tree_view);
15310   selection = gtk_tree_view_get_selection (tree_view);
15311
15312   /* search */
15313   gtk_tree_selection_unselect_all (selection);
15314   if (!gtk_tree_model_get_iter_first (model, &iter))
15315     return TRUE;
15316
15317   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
15318                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
15319
15320   if (ret)
15321     {
15322       /* found */
15323       tree_view->priv->selected_iter += up?(-1):(1);
15324       return TRUE;
15325     }
15326   else
15327     {
15328       /* return to old iter */
15329       count = 0;
15330       gtk_tree_model_get_iter_first (model, &iter);
15331       gtk_tree_view_search_iter (model, selection,
15332                                  &iter, text,
15333                                  &count, tree_view->priv->selected_iter);
15334       return FALSE;
15335     }
15336 }
15337
15338 static gboolean
15339 gtk_tree_view_search_equal_func (GtkTreeModel *model,
15340                                  gint          column,
15341                                  const gchar  *key,
15342                                  GtkTreeIter  *iter,
15343                                  gpointer      search_data)
15344 {
15345   gboolean retval = TRUE;
15346   const gchar *str;
15347   gchar *normalized_string;
15348   gchar *normalized_key;
15349   gchar *case_normalized_string = NULL;
15350   gchar *case_normalized_key = NULL;
15351   GValue value = G_VALUE_INIT;
15352   GValue transformed = G_VALUE_INIT;
15353
15354   gtk_tree_model_get_value (model, iter, column, &value);
15355
15356   g_value_init (&transformed, G_TYPE_STRING);
15357
15358   if (!g_value_transform (&value, &transformed))
15359     {
15360       g_value_unset (&value);
15361       return TRUE;
15362     }
15363
15364   g_value_unset (&value);
15365
15366   str = g_value_get_string (&transformed);
15367   if (!str)
15368     {
15369       g_value_unset (&transformed);
15370       return TRUE;
15371     }
15372
15373   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
15374   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
15375
15376   if (normalized_string && normalized_key)
15377     {
15378       case_normalized_string = g_utf8_casefold (normalized_string, -1);
15379       case_normalized_key = g_utf8_casefold (normalized_key, -1);
15380
15381       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
15382         retval = FALSE;
15383     }
15384
15385   g_value_unset (&transformed);
15386   g_free (normalized_key);
15387   g_free (normalized_string);
15388   g_free (case_normalized_key);
15389   g_free (case_normalized_string);
15390
15391   return retval;
15392 }
15393
15394 static gboolean
15395 gtk_tree_view_search_iter (GtkTreeModel     *model,
15396                            GtkTreeSelection *selection,
15397                            GtkTreeIter      *iter,
15398                            const gchar      *text,
15399                            gint             *count,
15400                            gint              n)
15401 {
15402   GtkRBTree *tree = NULL;
15403   GtkRBNode *node = NULL;
15404   GtkTreePath *path;
15405
15406   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
15407
15408   path = gtk_tree_model_get_path (model, iter);
15409   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15410
15411   do
15412     {
15413       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
15414         {
15415           (*count)++;
15416           if (*count == n)
15417             {
15418               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
15419                                             TRUE, 0.5, 0.0);
15420               gtk_tree_selection_select_iter (selection, iter);
15421               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15422
15423               if (path)
15424                 gtk_tree_path_free (path);
15425
15426               return TRUE;
15427             }
15428         }
15429
15430       if (node->children)
15431         {
15432           gboolean has_child;
15433           GtkTreeIter tmp;
15434
15435           tree = node->children;
15436           node = _gtk_rbtree_first (tree);
15437
15438           tmp = *iter;
15439           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
15440           gtk_tree_path_down (path);
15441
15442           /* sanity check */
15443           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
15444         }
15445       else
15446         {
15447           gboolean done = FALSE;
15448
15449           do
15450             {
15451               node = _gtk_rbtree_next (tree, node);
15452
15453               if (node)
15454                 {
15455                   gboolean has_next;
15456
15457                   has_next = gtk_tree_model_iter_next (model, iter);
15458
15459                   done = TRUE;
15460                   gtk_tree_path_next (path);
15461
15462                   /* sanity check */
15463                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
15464                 }
15465               else
15466                 {
15467                   gboolean has_parent;
15468                   GtkTreeIter tmp_iter = *iter;
15469
15470                   node = tree->parent_node;
15471                   tree = tree->parent_tree;
15472
15473                   if (!tree)
15474                     {
15475                       if (path)
15476                         gtk_tree_path_free (path);
15477
15478                       /* we've run out of tree, done with this func */
15479                       return FALSE;
15480                     }
15481
15482                   has_parent = gtk_tree_model_iter_parent (model,
15483                                                            iter,
15484                                                            &tmp_iter);
15485                   gtk_tree_path_up (path);
15486
15487                   /* sanity check */
15488                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
15489                 }
15490             }
15491           while (!done);
15492         }
15493     }
15494   while (1);
15495
15496   return FALSE;
15497 }
15498
15499 static void
15500 gtk_tree_view_search_init (GtkWidget   *entry,
15501                            GtkTreeView *tree_view)
15502 {
15503   gint ret;
15504   gint count = 0;
15505   const gchar *text;
15506   GtkTreeIter iter;
15507   GtkTreeModel *model;
15508   GtkTreeSelection *selection;
15509
15510   g_return_if_fail (GTK_IS_ENTRY (entry));
15511   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15512
15513   text = gtk_entry_get_text (GTK_ENTRY (entry));
15514
15515   model = gtk_tree_view_get_model (tree_view);
15516   selection = gtk_tree_view_get_selection (tree_view);
15517
15518   /* search */
15519   gtk_tree_selection_unselect_all (selection);
15520   if (tree_view->priv->typeselect_flush_timeout
15521       && !tree_view->priv->search_custom_entry_set)
15522     {
15523       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15524       tree_view->priv->typeselect_flush_timeout =
15525         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15526                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15527                        tree_view);
15528     }
15529
15530   if (*text == '\0')
15531     return;
15532
15533   if (!gtk_tree_model_get_iter_first (model, &iter))
15534     return;
15535
15536   ret = gtk_tree_view_search_iter (model, selection,
15537                                    &iter, text,
15538                                    &count, 1);
15539
15540   if (ret)
15541     tree_view->priv->selected_iter = 1;
15542 }
15543
15544 void
15545 _gtk_tree_view_remove_editable (GtkTreeView       *tree_view,
15546                                 GtkTreeViewColumn *column,
15547                                 GtkCellEditable   *cell_editable)
15548 {
15549   if (tree_view->priv->edited_column == NULL)
15550     return;
15551
15552   g_return_if_fail (column == tree_view->priv->edited_column);
15553
15554   tree_view->priv->edited_column = NULL;
15555
15556   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
15557     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
15558
15559   gtk_container_remove (GTK_CONTAINER (tree_view),
15560                         GTK_WIDGET (cell_editable));
15561
15562   /* FIXME should only redraw a single node */
15563   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15564 }
15565
15566 static gboolean
15567 gtk_tree_view_start_editing (GtkTreeView *tree_view,
15568                              GtkTreePath *cursor_path,
15569                              gboolean     edit_only)
15570 {
15571   GtkTreeIter iter;
15572   GdkRectangle cell_area;
15573   GtkTreeViewColumn *focus_column;
15574   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
15575   gint retval = FALSE;
15576   GtkRBTree *cursor_tree;
15577   GtkRBNode *cursor_node;
15578
15579   g_assert (tree_view->priv->focus_column);
15580   focus_column = tree_view->priv->focus_column;
15581
15582   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
15583     return FALSE;
15584
15585   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
15586       cursor_node == NULL)
15587     return FALSE;
15588
15589   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
15590
15591   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
15592
15593   gtk_tree_view_column_cell_set_cell_data (focus_column,
15594                                            tree_view->priv->model,
15595                                            &iter,
15596                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
15597                                            cursor_node->children ? TRUE : FALSE);
15598   gtk_tree_view_get_cell_area (tree_view,
15599                                cursor_path,
15600                                focus_column,
15601                                &cell_area);
15602
15603   if (gtk_cell_area_activate (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (focus_column)),
15604                               _gtk_tree_view_column_get_context (focus_column),
15605                               GTK_WIDGET (tree_view),
15606                               &cell_area,
15607                               flags, edit_only))
15608     retval = TRUE;
15609
15610   return retval;
15611 }
15612
15613 void
15614 _gtk_tree_view_add_editable (GtkTreeView       *tree_view,
15615                              GtkTreeViewColumn *column,
15616                              GtkTreePath       *path,
15617                              GtkCellEditable   *cell_editable,
15618                              GdkRectangle      *cell_area)
15619 {
15620   gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
15621   GtkRequisition requisition;
15622
15623   tree_view->priv->edited_column = column;
15624
15625   gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15626   cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
15627
15628   gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
15629                                  &requisition, NULL);
15630
15631   tree_view->priv->draw_keyfocus = TRUE;
15632
15633   if (requisition.height < cell_area->height)
15634     {
15635       gint diff = cell_area->height - requisition.height;
15636       gtk_tree_view_put (tree_view,
15637                          GTK_WIDGET (cell_editable),
15638                          cell_area->x, cell_area->y + diff/2,
15639                          cell_area->width, requisition.height);
15640     }
15641   else
15642     {
15643       gtk_tree_view_put (tree_view,
15644                          GTK_WIDGET (cell_editable),
15645                          cell_area->x, cell_area->y,
15646                          cell_area->width, cell_area->height);
15647     }
15648 }
15649
15650 static void
15651 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
15652                             gboolean     cancel_editing)
15653 {
15654   GtkTreeViewColumn *column;
15655
15656   if (tree_view->priv->edited_column == NULL)
15657     return;
15658
15659   /*
15660    * This is very evil. We need to do this, because
15661    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
15662    * later on. If gtk_tree_view_row_changed notices
15663    * tree_view->priv->edited_column != NULL, it'll call
15664    * gtk_tree_view_stop_editing again. Bad things will happen then.
15665    *
15666    * Please read that again if you intend to modify anything here.
15667    */
15668
15669   column = tree_view->priv->edited_column;
15670   gtk_cell_area_stop_editing (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)), cancel_editing);
15671   tree_view->priv->edited_column = NULL;
15672 }
15673
15674
15675 /**
15676  * gtk_tree_view_set_hover_selection:
15677  * @tree_view: a #GtkTreeView
15678  * @hover: %TRUE to enable hover selection mode
15679  *
15680  * Enables or disables the hover selection mode of @tree_view.
15681  * Hover selection makes the selected row follow the pointer.
15682  * Currently, this works only for the selection modes
15683  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
15684  *
15685  * Since: 2.6
15686  **/
15687 void
15688 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
15689                                    gboolean     hover)
15690 {
15691   hover = hover != FALSE;
15692
15693   if (hover != tree_view->priv->hover_selection)
15694     {
15695       tree_view->priv->hover_selection = hover;
15696
15697       g_object_notify (G_OBJECT (tree_view), "hover-selection");
15698     }
15699 }
15700
15701 /**
15702  * gtk_tree_view_get_hover_selection:
15703  * @tree_view: a #GtkTreeView
15704  *
15705  * Returns whether hover selection mode is turned on for @tree_view.
15706  *
15707  * Return value: %TRUE if @tree_view is in hover selection mode
15708  *
15709  * Since: 2.6
15710  **/
15711 gboolean
15712 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
15713 {
15714   return tree_view->priv->hover_selection;
15715 }
15716
15717 /**
15718  * gtk_tree_view_set_hover_expand:
15719  * @tree_view: a #GtkTreeView
15720  * @expand: %TRUE to enable hover selection mode
15721  *
15722  * Enables or disables the hover expansion mode of @tree_view.
15723  * Hover expansion makes rows expand or collapse if the pointer
15724  * moves over them.
15725  *
15726  * Since: 2.6
15727  **/
15728 void
15729 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
15730                                 gboolean     expand)
15731 {
15732   expand = expand != FALSE;
15733
15734   if (expand != tree_view->priv->hover_expand)
15735     {
15736       tree_view->priv->hover_expand = expand;
15737
15738       g_object_notify (G_OBJECT (tree_view), "hover-expand");
15739     }
15740 }
15741
15742 /**
15743  * gtk_tree_view_get_hover_expand:
15744  * @tree_view: a #GtkTreeView
15745  *
15746  * Returns whether hover expansion mode is turned on for @tree_view.
15747  *
15748  * Return value: %TRUE if @tree_view is in hover expansion mode
15749  *
15750  * Since: 2.6
15751  **/
15752 gboolean
15753 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
15754 {
15755   return tree_view->priv->hover_expand;
15756 }
15757
15758 /**
15759  * gtk_tree_view_set_rubber_banding:
15760  * @tree_view: a #GtkTreeView
15761  * @enable: %TRUE to enable rubber banding
15762  *
15763  * Enables or disables rubber banding in @tree_view.  If the selection mode
15764  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
15765  * multiple rows by dragging the mouse.
15766  *
15767  * Since: 2.10
15768  **/
15769 void
15770 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
15771                                   gboolean     enable)
15772 {
15773   enable = enable != FALSE;
15774
15775   if (enable != tree_view->priv->rubber_banding_enable)
15776     {
15777       tree_view->priv->rubber_banding_enable = enable;
15778
15779       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
15780     }
15781 }
15782
15783 /**
15784  * gtk_tree_view_get_rubber_banding:
15785  * @tree_view: a #GtkTreeView
15786  *
15787  * Returns whether rubber banding is turned on for @tree_view.  If the
15788  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15789  * user to select multiple rows by dragging the mouse.
15790  *
15791  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15792  *
15793  * Since: 2.10
15794  **/
15795 gboolean
15796 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15797 {
15798   return tree_view->priv->rubber_banding_enable;
15799 }
15800
15801 /**
15802  * gtk_tree_view_is_rubber_banding_active:
15803  * @tree_view: a #GtkTreeView
15804  *
15805  * Returns whether a rubber banding operation is currently being done
15806  * in @tree_view.
15807  *
15808  * Return value: %TRUE if a rubber banding operation is currently being
15809  * done in @tree_view.
15810  *
15811  * Since: 2.12
15812  **/
15813 gboolean
15814 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15815 {
15816   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15817
15818   if (tree_view->priv->rubber_banding_enable
15819       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15820     return TRUE;
15821
15822   return FALSE;
15823 }
15824
15825 /**
15826  * gtk_tree_view_get_row_separator_func: (skip)
15827  * @tree_view: a #GtkTreeView
15828  *
15829  * Returns the current row separator function.
15830  *
15831  * Return value: the current row separator function.
15832  *
15833  * Since: 2.6
15834  **/
15835 GtkTreeViewRowSeparatorFunc
15836 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15837 {
15838   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15839
15840   return tree_view->priv->row_separator_func;
15841 }
15842
15843 /**
15844  * gtk_tree_view_set_row_separator_func:
15845  * @tree_view: a #GtkTreeView
15846  * @func: (allow-none): a #GtkTreeViewRowSeparatorFunc
15847  * @data: (allow-none): user data to pass to @func, or %NULL
15848  * @destroy: (allow-none): destroy notifier for @data, or %NULL
15849  *
15850  * Sets the row separator function, which is used to determine
15851  * whether a row should be drawn as a separator. If the row separator
15852  * function is %NULL, no separators are drawn. This is the default value.
15853  *
15854  * Since: 2.6
15855  **/
15856 void
15857 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15858                                       GtkTreeViewRowSeparatorFunc  func,
15859                                       gpointer                     data,
15860                                       GDestroyNotify               destroy)
15861 {
15862   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15863
15864   if (tree_view->priv->row_separator_destroy)
15865     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15866
15867   tree_view->priv->row_separator_func = func;
15868   tree_view->priv->row_separator_data = data;
15869   tree_view->priv->row_separator_destroy = destroy;
15870
15871   /* Have the tree recalculate heights */
15872   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15873   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15874 }
15875
15876
15877 static void
15878 gtk_tree_view_grab_notify (GtkWidget *widget,
15879                            gboolean   was_grabbed)
15880 {
15881   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15882
15883   tree_view->priv->in_grab = !was_grabbed;
15884
15885   if (!was_grabbed)
15886     {
15887       tree_view->priv->pressed_button = -1;
15888
15889       if (tree_view->priv->rubber_band_status)
15890         gtk_tree_view_stop_rubber_band (tree_view);
15891     }
15892 }
15893
15894 static void
15895 gtk_tree_view_state_flags_changed (GtkWidget     *widget,
15896                                    GtkStateFlags  previous_state)
15897 {
15898   if (gtk_widget_get_realized (widget))
15899     gtk_tree_view_ensure_background (GTK_TREE_VIEW (widget));
15900
15901   gtk_widget_queue_draw (widget);
15902 }
15903
15904 /**
15905  * gtk_tree_view_get_grid_lines:
15906  * @tree_view: a #GtkTreeView
15907  *
15908  * Returns which grid lines are enabled in @tree_view.
15909  *
15910  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15911  * are enabled.
15912  *
15913  * Since: 2.10
15914  */
15915 GtkTreeViewGridLines
15916 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15917 {
15918   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15919
15920   return tree_view->priv->grid_lines;
15921 }
15922
15923 /**
15924  * gtk_tree_view_set_grid_lines:
15925  * @tree_view: a #GtkTreeView
15926  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15927  * enable.
15928  *
15929  * Sets which grid lines to draw in @tree_view.
15930  *
15931  * Since: 2.10
15932  */
15933 void
15934 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15935                               GtkTreeViewGridLines   grid_lines)
15936 {
15937   GtkTreeViewPrivate *priv;
15938   GtkWidget *widget;
15939   GtkTreeViewGridLines old_grid_lines;
15940
15941   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15942
15943   priv = tree_view->priv;
15944   widget = GTK_WIDGET (tree_view);
15945
15946   old_grid_lines = priv->grid_lines;
15947   priv->grid_lines = grid_lines;
15948
15949   if (gtk_widget_get_realized (widget))
15950     {
15951       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15952           priv->grid_line_width)
15953         {
15954           priv->grid_line_width = 0;
15955         }
15956
15957       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15958           !priv->grid_line_width)
15959         {
15960           gint8 *dash_list;
15961
15962           gtk_widget_style_get (widget,
15963                                 "grid-line-width", &priv->grid_line_width,
15964                                 "grid-line-pattern", (gchar *)&dash_list,
15965                                 NULL);
15966
15967           if (dash_list)
15968             {
15969               priv->grid_line_dashes[0] = dash_list[0];
15970               if (dash_list[0])
15971                 priv->grid_line_dashes[1] = dash_list[1];
15972
15973               g_free (dash_list);
15974             }
15975           else
15976             {
15977               priv->grid_line_dashes[0] = 1;
15978               priv->grid_line_dashes[1] = 1;
15979             }
15980         }
15981     }
15982
15983   if (old_grid_lines != grid_lines)
15984     {
15985       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15986
15987       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
15988     }
15989 }
15990
15991 /**
15992  * gtk_tree_view_get_enable_tree_lines:
15993  * @tree_view: a #GtkTreeView.
15994  *
15995  * Returns whether or not tree lines are drawn in @tree_view.
15996  *
15997  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
15998  * otherwise.
15999  *
16000  * Since: 2.10
16001  */
16002 gboolean
16003 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
16004 {
16005   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16006
16007   return tree_view->priv->tree_lines_enabled;
16008 }
16009
16010 /**
16011  * gtk_tree_view_set_enable_tree_lines:
16012  * @tree_view: a #GtkTreeView
16013  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
16014  *
16015  * Sets whether to draw lines interconnecting the expanders in @tree_view.
16016  * This does not have any visible effects for lists.
16017  *
16018  * Since: 2.10
16019  */
16020 void
16021 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
16022                                      gboolean     enabled)
16023 {
16024   GtkTreeViewPrivate *priv;
16025   GtkWidget *widget;
16026   gboolean was_enabled;
16027
16028   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16029
16030   enabled = enabled != FALSE;
16031
16032   priv = tree_view->priv;
16033   widget = GTK_WIDGET (tree_view);
16034
16035   was_enabled = priv->tree_lines_enabled;
16036
16037   priv->tree_lines_enabled = enabled;
16038
16039   if (gtk_widget_get_realized (widget))
16040     {
16041       if (!enabled && priv->tree_line_width)
16042         {
16043           priv->tree_line_width = 0;
16044         }
16045
16046       if (enabled && !priv->tree_line_width)
16047         {
16048           gint8 *dash_list;
16049           gtk_widget_style_get (widget,
16050                                 "tree-line-width", &priv->tree_line_width,
16051                                 "tree-line-pattern", (gchar *)&dash_list,
16052                                 NULL);
16053
16054           if (dash_list)
16055             {
16056               priv->tree_line_dashes[0] = dash_list[0];
16057               if (dash_list[0])
16058                 priv->tree_line_dashes[1] = dash_list[1];
16059
16060               g_free (dash_list);
16061             }
16062           else
16063             {
16064               priv->tree_line_dashes[0] = 1;
16065               priv->tree_line_dashes[1] = 1;
16066             }
16067         }
16068     }
16069
16070   if (was_enabled != enabled)
16071     {
16072       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16073
16074       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
16075     }
16076 }
16077
16078
16079 /**
16080  * gtk_tree_view_set_show_expanders:
16081  * @tree_view: a #GtkTreeView
16082  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
16083  *
16084  * Sets whether to draw and enable expanders and indent child rows in
16085  * @tree_view.  When disabled there will be no expanders visible in trees
16086  * and there will be no way to expand and collapse rows by default.  Also
16087  * note that hiding the expanders will disable the default indentation.  You
16088  * can set a custom indentation in this case using
16089  * gtk_tree_view_set_level_indentation().
16090  * This does not have any visible effects for lists.
16091  *
16092  * Since: 2.12
16093  */
16094 void
16095 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
16096                                   gboolean     enabled)
16097 {
16098   gboolean was_enabled;
16099
16100   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16101
16102   enabled = enabled != FALSE;
16103   was_enabled = tree_view->priv->show_expanders;
16104
16105   tree_view->priv->show_expanders = enabled == TRUE;
16106
16107   if (enabled != was_enabled)
16108     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16109 }
16110
16111 /**
16112  * gtk_tree_view_get_show_expanders:
16113  * @tree_view: a #GtkTreeView.
16114  *
16115  * Returns whether or not expanders are drawn in @tree_view.
16116  *
16117  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
16118  * otherwise.
16119  *
16120  * Since: 2.12
16121  */
16122 gboolean
16123 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
16124 {
16125   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16126
16127   return tree_view->priv->show_expanders;
16128 }
16129
16130 /**
16131  * gtk_tree_view_set_level_indentation:
16132  * @tree_view: a #GtkTreeView
16133  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
16134  *
16135  * Sets the amount of extra indentation for child levels to use in @tree_view
16136  * in addition to the default indentation.  The value should be specified in
16137  * pixels, a value of 0 disables this feature and in this case only the default
16138  * indentation will be used.
16139  * This does not have any visible effects for lists.
16140  *
16141  * Since: 2.12
16142  */
16143 void
16144 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
16145                                      gint         indentation)
16146 {
16147   tree_view->priv->level_indentation = indentation;
16148
16149   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16150 }
16151
16152 /**
16153  * gtk_tree_view_get_level_indentation:
16154  * @tree_view: a #GtkTreeView.
16155  *
16156  * Returns the amount, in pixels, of extra indentation for child levels
16157  * in @tree_view.
16158  *
16159  * Return value: the amount of extra indentation for child levels in
16160  * @tree_view.  A return value of 0 means that this feature is disabled.
16161  *
16162  * Since: 2.12
16163  */
16164 gint
16165 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
16166 {
16167   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16168
16169   return tree_view->priv->level_indentation;
16170 }
16171
16172 /**
16173  * gtk_tree_view_set_tooltip_row:
16174  * @tree_view: a #GtkTreeView
16175  * @tooltip: a #GtkTooltip
16176  * @path: a #GtkTreePath
16177  *
16178  * Sets the tip area of @tooltip to be the area covered by the row at @path.
16179  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16180  * See also gtk_tooltip_set_tip_area().
16181  *
16182  * Since: 2.12
16183  */
16184 void
16185 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
16186                                GtkTooltip  *tooltip,
16187                                GtkTreePath *path)
16188 {
16189   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16190   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16191
16192   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
16193 }
16194
16195 /**
16196  * gtk_tree_view_set_tooltip_cell:
16197  * @tree_view: a #GtkTreeView
16198  * @tooltip: a #GtkTooltip
16199  * @path: (allow-none): a #GtkTreePath or %NULL
16200  * @column: (allow-none): a #GtkTreeViewColumn or %NULL
16201  * @cell: (allow-none): a #GtkCellRenderer or %NULL
16202  *
16203  * Sets the tip area of @tooltip to the area @path, @column and @cell have
16204  * in common.  For example if @path is %NULL and @column is set, the tip
16205  * area will be set to the full area covered by @column.  See also
16206  * gtk_tooltip_set_tip_area().
16207  *
16208  * Note that if @path is not specified and @cell is set and part of a column
16209  * containing the expander, the tooltip might not show and hide at the correct
16210  * position.  In such cases @path must be set to the current node under the
16211  * mouse cursor for this function to operate correctly.
16212  *
16213  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16214  *
16215  * Since: 2.12
16216  */
16217 void
16218 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
16219                                 GtkTooltip        *tooltip,
16220                                 GtkTreePath       *path,
16221                                 GtkTreeViewColumn *column,
16222                                 GtkCellRenderer   *cell)
16223 {
16224   GtkAllocation allocation;
16225   GdkRectangle rect;
16226
16227   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16228   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16229   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
16230   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
16231
16232   /* Determine x values. */
16233   if (column && cell)
16234     {
16235       GdkRectangle tmp;
16236       gint start, width;
16237
16238       /* We always pass in path here, whether it is NULL or not.
16239        * For cells in expander columns path must be specified so that
16240        * we can correctly account for the indentation.  This also means
16241        * that the tooltip is constrained vertically by the "Determine y
16242        * values" code below; this is not a real problem since cells actually
16243        * don't stretch vertically in constrast to columns.
16244        */
16245       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
16246       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
16247
16248       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16249                                                          tmp.x + start, 0,
16250                                                          &rect.x, NULL);
16251       rect.width = width;
16252     }
16253   else if (column)
16254     {
16255       GdkRectangle tmp;
16256
16257       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
16258       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16259                                                          tmp.x, 0,
16260                                                          &rect.x, NULL);
16261       rect.width = tmp.width;
16262     }
16263   else
16264     {
16265       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
16266       rect.x = 0;
16267       rect.width = allocation.width;
16268     }
16269
16270   /* Determine y values. */
16271   if (path)
16272     {
16273       GdkRectangle tmp;
16274
16275       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
16276       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16277                                                          0, tmp.y,
16278                                                          NULL, &rect.y);
16279       rect.height = tmp.height;
16280     }
16281   else
16282     {
16283       rect.y = 0;
16284       rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
16285     }
16286
16287   gtk_tooltip_set_tip_area (tooltip, &rect);
16288 }
16289
16290 /**
16291  * gtk_tree_view_get_tooltip_context:
16292  * @tree_view: a #GtkTreeView
16293  * @x: (inout): the x coordinate (relative to widget coordinates)
16294  * @y: (inout): the y coordinate (relative to widget coordinates)
16295  * @keyboard_tip: whether this is a keyboard tooltip or not
16296  * @model: (out) (allow-none) (transfer none): a pointer to receive a
16297  *         #GtkTreeModel or %NULL
16298  * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
16299  * @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
16300  *
16301  * This function is supposed to be used in a #GtkWidget::query-tooltip
16302  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
16303  * which are received in the signal handler, should be passed to this
16304  * function without modification.
16305  *
16306  * The return value indicates whether there is a tree view row at the given
16307  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
16308  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
16309  * @model, @path and @iter which have been provided will be set to point to
16310  * that row and the corresponding model.  @x and @y will always be converted
16311  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
16312  *
16313  * Return value: whether or not the given tooltip context points to a row.
16314  *
16315  * Since: 2.12
16316  */
16317 gboolean
16318 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
16319                                    gint          *x,
16320                                    gint          *y,
16321                                    gboolean       keyboard_tip,
16322                                    GtkTreeModel **model,
16323                                    GtkTreePath  **path,
16324                                    GtkTreeIter   *iter)
16325 {
16326   GtkTreePath *tmppath = NULL;
16327
16328   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16329   g_return_val_if_fail (x != NULL, FALSE);
16330   g_return_val_if_fail (y != NULL, FALSE);
16331
16332   if (keyboard_tip)
16333     {
16334       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
16335
16336       if (!tmppath)
16337         return FALSE;
16338     }
16339   else
16340     {
16341       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
16342                                                          x, y);
16343
16344       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
16345                                           &tmppath, NULL, NULL, NULL))
16346         return FALSE;
16347     }
16348
16349   if (model)
16350     *model = gtk_tree_view_get_model (tree_view);
16351
16352   if (iter)
16353     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
16354                              iter, tmppath);
16355
16356   if (path)
16357     *path = tmppath;
16358   else
16359     gtk_tree_path_free (tmppath);
16360
16361   return TRUE;
16362 }
16363
16364 static gboolean
16365 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
16366                                     gint        x,
16367                                     gint        y,
16368                                     gboolean    keyboard_tip,
16369                                     GtkTooltip *tooltip,
16370                                     gpointer    data)
16371 {
16372   GValue value = G_VALUE_INIT;
16373   GValue transformed = G_VALUE_INIT;
16374   GtkTreeIter iter;
16375   GtkTreePath *path;
16376   GtkTreeModel *model;
16377   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
16378
16379   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
16380                                           &x, &y,
16381                                           keyboard_tip,
16382                                           &model, &path, &iter))
16383     return FALSE;
16384
16385   gtk_tree_model_get_value (model, &iter,
16386                             tree_view->priv->tooltip_column, &value);
16387
16388   g_value_init (&transformed, G_TYPE_STRING);
16389
16390   if (!g_value_transform (&value, &transformed))
16391     {
16392       g_value_unset (&value);
16393       gtk_tree_path_free (path);
16394
16395       return FALSE;
16396     }
16397
16398   g_value_unset (&value);
16399
16400   if (!g_value_get_string (&transformed))
16401     {
16402       g_value_unset (&transformed);
16403       gtk_tree_path_free (path);
16404
16405       return FALSE;
16406     }
16407
16408   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
16409   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
16410
16411   gtk_tree_path_free (path);
16412   g_value_unset (&transformed);
16413
16414   return TRUE;
16415 }
16416
16417 /**
16418  * gtk_tree_view_set_tooltip_column:
16419  * @tree_view: a #GtkTreeView
16420  * @column: an integer, which is a valid column number for @tree_view's model
16421  *
16422  * If you only plan to have simple (text-only) tooltips on full rows, you
16423  * can use this function to have #GtkTreeView handle these automatically
16424  * for you. @column should be set to the column in @tree_view's model
16425  * containing the tooltip texts, or -1 to disable this feature.
16426  *
16427  * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
16428  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
16429  *
16430  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
16431  * so &amp;, &lt;, etc have to be escaped in the text.
16432  *
16433  * Since: 2.12
16434  */
16435 void
16436 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
16437                                   gint         column)
16438 {
16439   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16440
16441   if (column == tree_view->priv->tooltip_column)
16442     return;
16443
16444   if (column == -1)
16445     {
16446       g_signal_handlers_disconnect_by_func (tree_view,
16447                                             gtk_tree_view_set_tooltip_query_cb,
16448                                             NULL);
16449       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
16450     }
16451   else
16452     {
16453       if (tree_view->priv->tooltip_column == -1)
16454         {
16455           g_signal_connect (tree_view, "query-tooltip",
16456                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
16457           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
16458         }
16459     }
16460
16461   tree_view->priv->tooltip_column = column;
16462   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
16463 }
16464
16465 /**
16466  * gtk_tree_view_get_tooltip_column:
16467  * @tree_view: a #GtkTreeView
16468  *
16469  * Returns the column of @tree_view's model which is being used for
16470  * displaying tooltips on @tree_view's rows.
16471  *
16472  * Return value: the index of the tooltip column that is currently being
16473  * used, or -1 if this is disabled.
16474  *
16475  * Since: 2.12
16476  */
16477 gint
16478 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
16479 {
16480   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16481
16482   return tree_view->priv->tooltip_column;
16483 }