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, gtk_widget_path_length (path) - 2, GTK_STYLE_REGION_COLUMN_HEADER, flags);
8552       break;
8553     }
8554   g_list_free (visible_columns);
8555
8556   return path;
8557 }
8558
8559 static gboolean
8560 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8561                                 GtkMovementStep    step,
8562                                 gint               count)
8563 {
8564   GdkModifierType state;
8565
8566   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8567   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8568                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8569                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8570                         step == GTK_MOVEMENT_PAGES ||
8571                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8572
8573   if (tree_view->priv->tree == NULL)
8574     return FALSE;
8575   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8576     return FALSE;
8577
8578   gtk_tree_view_stop_editing (tree_view, FALSE);
8579   tree_view->priv->draw_keyfocus = TRUE;
8580   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8581
8582   if (gtk_get_current_event_state (&state))
8583     {
8584       GdkModifierType extend_mod_mask;
8585       GdkModifierType modify_mod_mask;
8586
8587       extend_mod_mask =
8588         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8589                                       GDK_MODIFIER_INTENT_EXTEND_SELECTION);
8590
8591       modify_mod_mask =
8592         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8593                                       GDK_MODIFIER_INTENT_MODIFY_SELECTION);
8594
8595       if ((state & modify_mod_mask) == modify_mod_mask)
8596         tree_view->priv->modify_selection_pressed = TRUE;
8597       if ((state & extend_mod_mask) == extend_mod_mask)
8598         tree_view->priv->extend_selection_pressed = TRUE;
8599     }
8600   /* else we assume not pressed */
8601
8602   switch (step)
8603     {
8604       /* currently we make no distinction.  When we go bi-di, we need to */
8605     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8606     case GTK_MOVEMENT_VISUAL_POSITIONS:
8607       gtk_tree_view_move_cursor_left_right (tree_view, count);
8608       break;
8609     case GTK_MOVEMENT_DISPLAY_LINES:
8610       gtk_tree_view_move_cursor_up_down (tree_view, count);
8611       break;
8612     case GTK_MOVEMENT_PAGES:
8613       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8614       break;
8615     case GTK_MOVEMENT_BUFFER_ENDS:
8616       gtk_tree_view_move_cursor_start_end (tree_view, count);
8617       break;
8618     default:
8619       g_assert_not_reached ();
8620     }
8621
8622   tree_view->priv->modify_selection_pressed = FALSE;
8623   tree_view->priv->extend_selection_pressed = FALSE;
8624
8625   return TRUE;
8626 }
8627
8628 static void
8629 gtk_tree_view_put (GtkTreeView *tree_view,
8630                    GtkWidget   *child_widget,
8631                    /* in bin_window coordinates */
8632                    gint         x,
8633                    gint         y,
8634                    gint         width,
8635                    gint         height)
8636 {
8637   GtkTreeViewChild *child;
8638
8639   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8640   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8641
8642   child = g_slice_new (GtkTreeViewChild);
8643
8644   child->widget = child_widget;
8645   child->x = x;
8646   child->y = y;
8647   child->width = width;
8648   child->height = height;
8649
8650   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8651
8652   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8653     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8654
8655   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8656 }
8657
8658 void
8659 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8660                                   GtkWidget   *widget,
8661                                   /* in tree coordinates */
8662                                   gint         x,
8663                                   gint         y,
8664                                   gint         width,
8665                                   gint         height)
8666 {
8667   GtkTreeViewChild *child = NULL;
8668   GList *list;
8669   GdkRectangle allocation;
8670
8671   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8672   g_return_if_fail (GTK_IS_WIDGET (widget));
8673
8674   for (list = tree_view->priv->children; list; list = list->next)
8675     {
8676       if (((GtkTreeViewChild *)list->data)->widget == widget)
8677         {
8678           child = list->data;
8679           break;
8680         }
8681     }
8682   if (child == NULL)
8683     return;
8684
8685   allocation.x = child->x = x;
8686   allocation.y = child->y = y;
8687   allocation.width = child->width = width;
8688   allocation.height = child->height = height;
8689
8690   if (gtk_widget_get_realized (widget))
8691     gtk_widget_size_allocate (widget, &allocation);
8692 }
8693
8694
8695 /* TreeModel Callbacks
8696  */
8697
8698 static void
8699 gtk_tree_view_row_changed (GtkTreeModel *model,
8700                            GtkTreePath  *path,
8701                            GtkTreeIter  *iter,
8702                            gpointer      data)
8703 {
8704   GtkTreeView *tree_view = (GtkTreeView *)data;
8705   GtkRBTree *tree;
8706   GtkRBNode *node;
8707   gboolean free_path = FALSE;
8708   GList *list;
8709   GtkTreePath *cursor_path;
8710
8711   g_return_if_fail (path != NULL || iter != NULL);
8712
8713   if (tree_view->priv->cursor_node != NULL)
8714     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
8715                                                   tree_view->priv->cursor_node);
8716   else
8717     cursor_path = NULL;
8718
8719   if (tree_view->priv->edited_column &&
8720       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8721     gtk_tree_view_stop_editing (tree_view, TRUE);
8722
8723   if (cursor_path != NULL)
8724     gtk_tree_path_free (cursor_path);
8725
8726   if (path == NULL)
8727     {
8728       path = gtk_tree_model_get_path (model, iter);
8729       free_path = TRUE;
8730     }
8731   else if (iter == NULL)
8732     gtk_tree_model_get_iter (model, iter, path);
8733
8734   if (_gtk_tree_view_find_node (tree_view,
8735                                 path,
8736                                 &tree,
8737                                 &node))
8738     /* We aren't actually showing the node */
8739     goto done;
8740
8741   if (tree == NULL)
8742     goto done;
8743
8744   _gtk_tree_view_accessible_changed (tree_view, tree, node);
8745
8746   if (tree_view->priv->fixed_height_mode
8747       && tree_view->priv->fixed_height >= 0)
8748     {
8749       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8750       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8751         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8752     }
8753   else
8754     {
8755       _gtk_rbtree_node_mark_invalid (tree, node);
8756       for (list = tree_view->priv->columns; list; list = list->next)
8757         {
8758           GtkTreeViewColumn *column;
8759
8760           column = list->data;
8761           if (!gtk_tree_view_column_get_visible (column))
8762             continue;
8763
8764           if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8765             {
8766               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8767             }
8768         }
8769     }
8770
8771  done:
8772   if (!tree_view->priv->fixed_height_mode &&
8773       gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8774     install_presize_handler (tree_view);
8775   if (free_path)
8776     gtk_tree_path_free (path);
8777 }
8778
8779 static void
8780 gtk_tree_view_row_inserted (GtkTreeModel *model,
8781                             GtkTreePath  *path,
8782                             GtkTreeIter  *iter,
8783                             gpointer      data)
8784 {
8785   GtkTreeView *tree_view = (GtkTreeView *) data;
8786   gint *indices;
8787   GtkRBTree *tree;
8788   GtkRBNode *tmpnode = NULL;
8789   gint depth;
8790   gint i = 0;
8791   gint height;
8792   gboolean free_path = FALSE;
8793   gboolean node_visible = TRUE;
8794
8795   g_return_if_fail (path != NULL || iter != NULL);
8796
8797   if (tree_view->priv->fixed_height_mode
8798       && tree_view->priv->fixed_height >= 0)
8799     height = tree_view->priv->fixed_height;
8800   else
8801     height = 0;
8802
8803   if (path == NULL)
8804     {
8805       path = gtk_tree_model_get_path (model, iter);
8806       free_path = TRUE;
8807     }
8808   else if (iter == NULL)
8809     gtk_tree_model_get_iter (model, iter, path);
8810
8811   if (tree_view->priv->tree == NULL)
8812     tree_view->priv->tree = _gtk_rbtree_new ();
8813
8814   tree = tree_view->priv->tree;
8815
8816   /* Update all row-references */
8817   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8818   depth = gtk_tree_path_get_depth (path);
8819   indices = gtk_tree_path_get_indices (path);
8820
8821   /* First, find the parent tree */
8822   while (i < depth - 1)
8823     {
8824       if (tree == NULL)
8825         {
8826           /* We aren't showing the node */
8827           node_visible = FALSE;
8828           goto done;
8829         }
8830
8831       tmpnode = _gtk_rbtree_find_count (tree, indices[i] + 1);
8832       if (tmpnode == NULL)
8833         {
8834           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8835                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8836                      "before the parent was inserted.");
8837           goto done;
8838         }
8839       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8840         {
8841           /* FIXME enforce correct behavior on model, probably */
8842           /* In theory, the model should have emitted has_child_toggled here.  We
8843            * try to catch it anyway, just to be safe, in case the model hasn't.
8844            */
8845           GtkTreePath *tmppath = _gtk_tree_path_new_from_rbtree (tree, tmpnode);
8846           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8847           gtk_tree_path_free (tmppath);
8848           goto done;
8849         }
8850
8851       tree = tmpnode->children;
8852       i++;
8853     }
8854
8855   if (tree == NULL)
8856     {
8857       node_visible = FALSE;
8858       goto done;
8859     }
8860
8861   /* ref the node */
8862   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8863   if (indices[depth - 1] == 0)
8864     {
8865       tmpnode = _gtk_rbtree_find_count (tree, 1);
8866       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8867     }
8868   else
8869     {
8870       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8871       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8872     }
8873
8874   _gtk_tree_view_accessible_add (tree_view, tree, tmpnode);
8875
8876  done:
8877   if (height > 0)
8878     {
8879       if (tree)
8880         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8881
8882       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8883         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8884       else
8885         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8886     }
8887   else
8888     install_presize_handler (tree_view);
8889   if (free_path)
8890     gtk_tree_path_free (path);
8891 }
8892
8893 static void
8894 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8895                                      GtkTreePath  *path,
8896                                      GtkTreeIter  *iter,
8897                                      gpointer      data)
8898 {
8899   GtkTreeView *tree_view = (GtkTreeView *)data;
8900   GtkTreeIter real_iter;
8901   gboolean has_child;
8902   GtkRBTree *tree;
8903   GtkRBNode *node;
8904   gboolean free_path = FALSE;
8905
8906   g_return_if_fail (path != NULL || iter != NULL);
8907
8908   if (iter)
8909     real_iter = *iter;
8910
8911   if (path == NULL)
8912     {
8913       path = gtk_tree_model_get_path (model, iter);
8914       free_path = TRUE;
8915     }
8916   else if (iter == NULL)
8917     gtk_tree_model_get_iter (model, &real_iter, path);
8918
8919   if (_gtk_tree_view_find_node (tree_view,
8920                                 path,
8921                                 &tree,
8922                                 &node))
8923     /* We aren't actually showing the node */
8924     goto done;
8925
8926   if (tree == NULL)
8927     goto done;
8928
8929   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8930   /* Sanity check.
8931    */
8932   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8933     goto done;
8934
8935   if (has_child)
8936     {
8937       GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8938       _gtk_tree_view_accessible_add_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8939     }
8940   else
8941     {
8942       GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8943       _gtk_tree_view_accessible_remove_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8944     }
8945
8946   if (has_child && tree_view->priv->is_list)
8947     {
8948       tree_view->priv->is_list = FALSE;
8949       if (tree_view->priv->show_expanders)
8950         {
8951           GList *list;
8952
8953           for (list = tree_view->priv->columns; list; list = list->next)
8954             if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
8955               {
8956                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8957                 break;
8958               }
8959         }
8960       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8961     }
8962   else
8963     {
8964       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8965     }
8966
8967  done:
8968   if (free_path)
8969     gtk_tree_path_free (path);
8970 }
8971
8972 static void
8973 count_children_helper (GtkRBTree *tree,
8974                        GtkRBNode *node,
8975                        gpointer   data)
8976 {
8977   if (node->children)
8978     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8979   (*((gint *)data))++;
8980 }
8981
8982 static void
8983 check_selection_helper (GtkRBTree *tree,
8984                         GtkRBNode *node,
8985                         gpointer   data)
8986 {
8987   gint *value = (gint *)data;
8988
8989   *value |= GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8990
8991   if (node->children && !*value)
8992     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8993 }
8994
8995 static void
8996 gtk_tree_view_row_deleted (GtkTreeModel *model,
8997                            GtkTreePath  *path,
8998                            gpointer      data)
8999 {
9000   GtkTreeView *tree_view = (GtkTreeView *)data;
9001   GtkRBTree *tree;
9002   GtkRBNode *node;
9003   GList *list;
9004   gboolean selection_changed = FALSE, cursor_changed = FALSE;
9005   GtkRBTree *cursor_tree = NULL;
9006   GtkRBNode *cursor_node = NULL;
9007
9008   g_return_if_fail (path != NULL);
9009
9010   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
9011
9012   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
9013     return;
9014
9015   if (tree == NULL)
9016     return;
9017
9018   /* check if the selection has been changed */
9019   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
9020                         check_selection_helper, &selection_changed);
9021
9022   for (list = tree_view->priv->columns; list; list = list->next)
9023     if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)) &&
9024         gtk_tree_view_column_get_sizing (GTK_TREE_VIEW_COLUMN (list->data)) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9025       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
9026
9027   /* Ensure we don't have a dangling pointer to a dead node */
9028   ensure_unprelighted (tree_view);
9029
9030   /* Cancel editting if we've started */
9031   gtk_tree_view_stop_editing (tree_view, TRUE);
9032
9033   /* If the cursor row got deleted, move the cursor to the next row */
9034   if (tree_view->priv->cursor_node &&
9035       (tree_view->priv->cursor_node == node ||
9036        (node->children && (tree_view->priv->cursor_tree == node->children ||
9037                            _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree)))))
9038     {
9039       GtkTreePath *cursor_path;
9040
9041       cursor_tree = tree;
9042       cursor_node = _gtk_rbtree_next (tree, node);
9043       /* find the first node that is not going to be deleted */
9044       while (cursor_node == NULL && cursor_tree->parent_tree)
9045         {
9046           cursor_node = _gtk_rbtree_next (cursor_tree->parent_tree,
9047                                           cursor_tree->parent_node);
9048           cursor_tree = cursor_tree->parent_tree;
9049         }
9050
9051       if (cursor_node != NULL)
9052         cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9053       else
9054         cursor_path = NULL;
9055
9056       if (cursor_path == NULL ||
9057           ! search_first_focusable_path (tree_view, &cursor_path, TRUE,
9058                                          &cursor_tree, &cursor_node))
9059         {
9060           /* It looks like we reached the end of the view without finding
9061            * a focusable row.  We will step backwards to find the last
9062            * focusable row.
9063            */
9064           _gtk_rbtree_prev_full (tree, node, &cursor_tree, &cursor_node);
9065           if (cursor_node)
9066             {
9067               cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9068               if (! search_first_focusable_path (tree_view, &cursor_path, FALSE,
9069                                                  &cursor_tree, &cursor_node))
9070                 cursor_node = NULL;
9071               gtk_tree_path_free (cursor_path);
9072             }
9073         }
9074       else if (cursor_path)
9075         gtk_tree_path_free (cursor_path);
9076
9077       cursor_changed = TRUE;
9078     }
9079
9080   if (tree_view->priv->destroy_count_func)
9081     {
9082       gint child_count = 0;
9083       if (node->children)
9084         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
9085       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
9086     }
9087
9088   if (tree->root->count == 1)
9089     {
9090       if (tree_view->priv->tree == tree)
9091         tree_view->priv->tree = NULL;
9092
9093       _gtk_tree_view_accessible_remove_state (tree_view,
9094                                               tree->parent_tree, tree->parent_node,
9095                                               GTK_CELL_RENDERER_EXPANDED);
9096       _gtk_tree_view_accessible_remove (tree_view, tree, NULL);
9097       _gtk_rbtree_remove (tree);
9098     }
9099   else
9100     {
9101       _gtk_tree_view_accessible_remove (tree_view, tree, node);
9102       _gtk_rbtree_remove_node (tree, node);
9103     }
9104
9105   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
9106     {
9107       gtk_tree_row_reference_free (tree_view->priv->top_row);
9108       tree_view->priv->top_row = NULL;
9109     }
9110
9111   install_scroll_sync_handler (tree_view);
9112
9113   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9114
9115   if (cursor_changed)
9116     {
9117       if (cursor_node)
9118         {
9119           GtkTreePath *cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9120           gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CURSOR_INVALID);
9121           gtk_tree_path_free (cursor_path);
9122         }
9123       else
9124         gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT | CURSOR_INVALID);
9125     }
9126   if (selection_changed)
9127     g_signal_emit_by_name (tree_view->priv->selection, "changed");
9128 }
9129
9130 static void
9131 gtk_tree_view_rows_reordered (GtkTreeModel *model,
9132                               GtkTreePath  *parent,
9133                               GtkTreeIter  *iter,
9134                               gint         *new_order,
9135                               gpointer      data)
9136 {
9137   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
9138   GtkRBTree *tree;
9139   GtkRBNode *node;
9140   gint len;
9141
9142   len = gtk_tree_model_iter_n_children (model, iter);
9143
9144   if (len < 2)
9145     return;
9146
9147   gtk_tree_row_reference_reordered (G_OBJECT (data),
9148                                     parent,
9149                                     iter,
9150                                     new_order);
9151
9152   if (_gtk_tree_view_find_node (tree_view,
9153                                 parent,
9154                                 &tree,
9155                                 &node))
9156     return;
9157
9158   /* We need to special case the parent path */
9159   if (tree == NULL)
9160     tree = tree_view->priv->tree;
9161   else
9162     tree = node->children;
9163
9164   if (tree == NULL)
9165     return;
9166
9167   if (tree_view->priv->edited_column)
9168     gtk_tree_view_stop_editing (tree_view, TRUE);
9169
9170   /* we need to be unprelighted */
9171   ensure_unprelighted (tree_view);
9172
9173   _gtk_rbtree_reorder (tree, new_order, len);
9174
9175   _gtk_tree_view_accessible_reorder (tree_view);
9176
9177   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
9178
9179   gtk_tree_view_dy_to_top_row (tree_view);
9180 }
9181
9182
9183 /* Internal tree functions
9184  */
9185
9186
9187 static void
9188 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
9189                                      GtkRBTree         *tree,
9190                                      GtkTreeViewColumn *column,
9191                                      gint              *x1,
9192                                      gint              *x2)
9193 {
9194   GtkTreeViewColumn *tmp_column = NULL;
9195   gint total_width;
9196   GList *list;
9197   gboolean rtl;
9198
9199   if (x1)
9200     *x1 = 0;
9201
9202   if (x2)
9203     *x2 = 0;
9204
9205   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9206
9207   total_width = 0;
9208   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9209        list;
9210        list = (rtl ? list->prev : list->next))
9211     {
9212       tmp_column = list->data;
9213
9214       if (tmp_column == column)
9215         break;
9216
9217       if (gtk_tree_view_column_get_visible (tmp_column))
9218         total_width += gtk_tree_view_column_get_width (tmp_column);
9219     }
9220
9221   if (tmp_column != column)
9222     {
9223       g_warning (G_STRLOC": passed-in column isn't in the tree");
9224       return;
9225     }
9226
9227   if (x1)
9228     *x1 = total_width;
9229
9230   if (x2)
9231     {
9232       if (gtk_tree_view_column_get_visible (column))
9233         *x2 = total_width + gtk_tree_view_column_get_width (column);
9234       else
9235         *x2 = total_width; /* width of 0 */
9236     }
9237 }
9238
9239 static void
9240 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
9241                                 GtkRBTree   *tree,
9242                                 gint        *x1,
9243                                 gint        *x2)
9244 {
9245   gint x_offset = 0;
9246   GList *list;
9247   GtkTreeViewColumn *tmp_column = NULL;
9248   gint total_width;
9249   gint expander_size;
9250   gboolean indent_expanders;
9251   gboolean rtl;
9252
9253   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9254   expander_size = gtk_tree_view_get_expander_size (tree_view);
9255
9256   total_width = 0;
9257   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9258        list;
9259        list = (rtl ? list->prev : list->next))
9260     {
9261       tmp_column = list->data;
9262
9263       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
9264         {
9265           if (rtl)
9266             x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - expander_size;
9267           else
9268             x_offset = total_width;
9269           break;
9270         }
9271
9272       if (gtk_tree_view_column_get_visible (tmp_column))
9273         total_width += gtk_tree_view_column_get_width (tmp_column);
9274     }
9275
9276   gtk_widget_style_get (GTK_WIDGET (tree_view),
9277                         "indent-expanders", &indent_expanders,
9278                         NULL);
9279
9280   if (indent_expanders)
9281     {
9282       if (rtl)
9283         x_offset -= expander_size * _gtk_rbtree_get_depth (tree);
9284       else
9285         x_offset += expander_size * _gtk_rbtree_get_depth (tree);
9286     }
9287
9288   *x1 = x_offset;
9289
9290   if (tmp_column &&
9291       gtk_tree_view_column_get_visible (tmp_column))
9292     /* +1 because x2 isn't included in the range. */
9293     *x2 = *x1 + expander_size + 1;
9294   else
9295     *x2 = *x1;
9296 }
9297
9298 static void
9299 gtk_tree_view_build_tree (GtkTreeView *tree_view,
9300                           GtkRBTree   *tree,
9301                           GtkTreeIter *iter,
9302                           gint         depth,
9303                           gboolean     recurse)
9304 {
9305   GtkRBNode *temp = NULL;
9306   GtkTreePath *path = NULL;
9307
9308   do
9309     {
9310       gtk_tree_model_ref_node (tree_view->priv->model, iter);
9311       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
9312
9313       if (tree_view->priv->fixed_height > 0)
9314         {
9315           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
9316             {
9317               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
9318               _gtk_rbtree_node_mark_valid (tree, temp);
9319             }
9320         }
9321
9322       if (tree_view->priv->is_list)
9323         continue;
9324
9325       if (recurse)
9326         {
9327           GtkTreeIter child;
9328
9329           if (!path)
9330             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
9331           else
9332             gtk_tree_path_next (path);
9333
9334           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
9335             {
9336               gboolean expand;
9337
9338               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
9339
9340               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
9341                   && !expand)
9342                 {
9343                   temp->children = _gtk_rbtree_new ();
9344                   temp->children->parent_tree = tree;
9345                   temp->children->parent_node = temp;
9346                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
9347                 }
9348             }
9349         }
9350
9351       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
9352         {
9353           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
9354             temp->flags ^= GTK_RBNODE_IS_PARENT;
9355         }
9356     }
9357   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
9358
9359   if (path)
9360     gtk_tree_path_free (path);
9361 }
9362
9363 /* Make sure the node is visible vertically */
9364 static void
9365 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
9366                                   GtkRBTree   *tree,
9367                                   GtkRBNode   *node)
9368 {
9369   gint node_dy, height;
9370   GtkTreePath *path = NULL;
9371
9372   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9373     return;
9374
9375   /* just return if the node is visible, avoiding a costly expose */
9376   node_dy = _gtk_rbtree_node_find_offset (tree, node);
9377   height = gtk_tree_view_get_row_height (tree_view, node);
9378   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
9379       && node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment)
9380       && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
9381                               + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
9382     return;
9383
9384   path = _gtk_tree_path_new_from_rbtree (tree, node);
9385   if (path)
9386     {
9387       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
9388       gtk_tree_path_free (path);
9389     }
9390 }
9391
9392 static void
9393 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
9394                                     GtkTreeViewColumn *column,
9395                                     gboolean           focus_to_cell)
9396 {
9397   GtkAllocation allocation;
9398   gint x, width;
9399
9400   if (column == NULL)
9401     return;
9402
9403   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
9404   x = allocation.x;
9405   width = allocation.width;
9406
9407   if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9408     {
9409       /* The column is larger than the horizontal page size.  If the
9410        * column has cells which can be focussed individually, then we make
9411        * sure the cell which gets focus is fully visible (if even the
9412        * focus cell is bigger than the page size, we make sure the
9413        * left-hand side of the cell is visible).
9414        *
9415        * If the column does not have an activatable cell, we
9416        * make sure the left-hand side of the column is visible.
9417        */
9418
9419       if (focus_to_cell && gtk_tree_view_has_can_focus_cell (tree_view))
9420         {
9421           GtkCellArea *cell_area;
9422           GtkCellRenderer *focus_cell;
9423
9424           cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
9425           focus_cell = gtk_cell_area_get_focus_cell (cell_area);
9426
9427           if (gtk_tree_view_column_cell_get_position (column, focus_cell,
9428                                                       &x, &width))
9429             {
9430               if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9431                 {
9432                   if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment) < x + width)
9433                     gtk_adjustment_set_value (tree_view->priv->hadjustment,
9434                                               x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9435                   else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9436                     gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9437                 }
9438             }
9439         }
9440
9441       gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9442     }
9443   else
9444     {
9445       if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
9446           gtk_adjustment_set_value (tree_view->priv->hadjustment,
9447                                     x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9448       else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9449         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9450   }
9451 }
9452
9453 /* This function could be more efficient.  I'll optimize it if profiling seems
9454  * to imply that it is important */
9455 GtkTreePath *
9456 _gtk_tree_path_new_from_rbtree (GtkRBTree   *tree,
9457                                 GtkRBNode   *node)
9458 {
9459   GtkTreePath *path;
9460   GtkRBTree *tmp_tree;
9461   GtkRBNode *tmp_node, *last;
9462   gint count;
9463
9464   path = gtk_tree_path_new ();
9465
9466   g_return_val_if_fail (node != NULL, path);
9467
9468   count = 1 + node->left->count;
9469
9470   last = node;
9471   tmp_node = node->parent;
9472   tmp_tree = tree;
9473   while (tmp_tree)
9474     {
9475       while (!_gtk_rbtree_is_nil (tmp_node))
9476         {
9477           if (tmp_node->right == last)
9478             count += 1 + tmp_node->left->count;
9479           last = tmp_node;
9480           tmp_node = tmp_node->parent;
9481         }
9482       gtk_tree_path_prepend_index (path, count - 1);
9483       last = tmp_tree->parent_node;
9484       tmp_tree = tmp_tree->parent_tree;
9485       if (last)
9486         {
9487           count = 1 + last->left->count;
9488           tmp_node = last->parent;
9489         }
9490     }
9491   return path;
9492 }
9493
9494 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
9495  * invalid (ie. points to a node that's not in the tree), *tree and *node are
9496  * both set to NULL.
9497  */
9498 gboolean
9499 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
9500                           GtkTreePath  *path,
9501                           GtkRBTree   **tree,
9502                           GtkRBNode   **node)
9503 {
9504   GtkRBNode *tmpnode = NULL;
9505   GtkRBTree *tmptree = tree_view->priv->tree;
9506   gint *indices = gtk_tree_path_get_indices (path);
9507   gint depth = gtk_tree_path_get_depth (path);
9508   gint i = 0;
9509
9510   *node = NULL;
9511   *tree = NULL;
9512
9513   if (depth == 0 || tmptree == NULL)
9514     return FALSE;
9515   do
9516     {
9517       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
9518       ++i;
9519       if (tmpnode == NULL)
9520         {
9521           *tree = NULL;
9522           *node = NULL;
9523           return FALSE;
9524         }
9525       if (i >= depth)
9526         {
9527           *tree = tmptree;
9528           *node = tmpnode;
9529           return FALSE;
9530         }
9531       *tree = tmptree;
9532       *node = tmpnode;
9533       tmptree = tmpnode->children;
9534       if (tmptree == NULL)
9535         return TRUE;
9536     }
9537   while (1);
9538 }
9539
9540 static gboolean
9541 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9542                                   GtkTreeViewColumn *column)
9543 {
9544   GList *list;
9545
9546   if (tree_view->priv->is_list)
9547     return FALSE;
9548
9549   if (tree_view->priv->expander_column != NULL)
9550     {
9551       if (tree_view->priv->expander_column == column)
9552         return TRUE;
9553       return FALSE;
9554     }
9555   else
9556     {
9557       for (list = tree_view->priv->columns;
9558            list;
9559            list = list->next)
9560         if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
9561           break;
9562       if (list && list->data == column)
9563         return TRUE;
9564     }
9565   return FALSE;
9566 }
9567
9568 static inline gboolean
9569 gtk_tree_view_draw_expanders (GtkTreeView *tree_view)
9570 {
9571   if (!tree_view->priv->is_list && tree_view->priv->show_expanders)
9572     return TRUE;
9573   /* else */
9574   return FALSE;
9575 }
9576
9577 static void
9578 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9579                                 guint           keyval,
9580                                 guint           modmask,
9581                                 gboolean        add_shifted_binding,
9582                                 GtkMovementStep step,
9583                                 gint            count)
9584 {
9585
9586   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9587                                 "move-cursor", 2,
9588                                 G_TYPE_ENUM, step,
9589                                 G_TYPE_INT, count);
9590
9591   if (add_shifted_binding)
9592     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9593                                   "move-cursor", 2,
9594                                   G_TYPE_ENUM, step,
9595                                   G_TYPE_INT, count);
9596
9597   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9598    return;
9599
9600   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9601                                 "move-cursor", 2,
9602                                 G_TYPE_ENUM, step,
9603                                 G_TYPE_INT, count);
9604
9605   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9606                                 "move-cursor", 2,
9607                                 G_TYPE_ENUM, step,
9608                                 G_TYPE_INT, count);
9609 }
9610
9611 static gint
9612 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9613                                  GtkTreeIter  *iter,
9614                                  GtkRBTree    *tree,
9615                                  GtkRBNode    *node)
9616 {
9617   gint retval = FALSE;
9618   do
9619     {
9620       g_return_val_if_fail (node != NULL, FALSE);
9621
9622       if (node->children)
9623         {
9624           GtkTreeIter child;
9625           GtkRBTree *new_tree;
9626           GtkRBNode *new_node;
9627
9628           new_tree = node->children;
9629           new_node = _gtk_rbtree_first (new_tree);
9630
9631           if (!gtk_tree_model_iter_children (model, &child, iter))
9632             return FALSE;
9633
9634           retval = gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node) | retval;
9635         }
9636
9637       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9638         retval = TRUE;
9639       gtk_tree_model_unref_node (model, iter);
9640       node = _gtk_rbtree_next (tree, node);
9641     }
9642   while (gtk_tree_model_iter_next (model, iter));
9643
9644   return retval;
9645 }
9646
9647 static gint
9648 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9649                                               GtkRBTree   *tree)
9650 {
9651   GtkTreeIter iter;
9652   GtkTreePath *path;
9653   GtkRBNode *node;
9654   gint retval;
9655
9656   if (!tree)
9657     return FALSE;
9658
9659   node = _gtk_rbtree_first (tree);
9660
9661   g_return_val_if_fail (node != NULL, FALSE);
9662   path = _gtk_tree_path_new_from_rbtree (tree, node);
9663   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9664                            &iter, path);
9665   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9666   gtk_tree_path_free (path);
9667
9668   return retval;
9669 }
9670
9671 static void
9672 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9673                                     GtkTreeViewColumn *column)
9674 {
9675   GtkTreeViewColumn *left_column;
9676   GtkTreeViewColumn *cur_column = NULL;
9677   GtkTreeViewColumnReorder *reorder;
9678   gboolean rtl;
9679   GList *tmp_list;
9680   gint left;
9681
9682   /* We want to precalculate the motion list such that we know what column slots
9683    * are available.
9684    */
9685   left_column = NULL;
9686   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9687
9688   /* First, identify all possible drop spots */
9689   if (rtl)
9690     tmp_list = g_list_last (tree_view->priv->columns);
9691   else
9692     tmp_list = g_list_first (tree_view->priv->columns);
9693
9694   while (tmp_list)
9695     {
9696       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9697       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9698
9699       if (gtk_tree_view_column_get_visible (cur_column) == FALSE)
9700         continue;
9701
9702       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9703       if (left_column != column && cur_column != column &&
9704           tree_view->priv->column_drop_func &&
9705           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9706         {
9707           left_column = cur_column;
9708           continue;
9709         }
9710       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9711       reorder->left_column = left_column;
9712       left_column = reorder->right_column = cur_column;
9713
9714       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9715     }
9716
9717   /* Add the last one */
9718   if (tree_view->priv->column_drop_func == NULL ||
9719       ((left_column != column) &&
9720        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9721     {
9722       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9723       reorder->left_column = left_column;
9724       reorder->right_column = NULL;
9725       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9726     }
9727
9728   /* We quickly check to see if it even makes sense to reorder columns. */
9729   /* If there is nothing that can be moved, then we return */
9730
9731   if (tree_view->priv->column_drag_info == NULL)
9732     return;
9733
9734   /* We know there are always 2 slots possbile, as you can always return column. */
9735   /* If that's all there is, return */
9736   if (tree_view->priv->column_drag_info->next == NULL ||
9737       (tree_view->priv->column_drag_info->next->next == NULL &&
9738        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9739        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9740     {
9741       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9742         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9743       g_list_free (tree_view->priv->column_drag_info);
9744       tree_view->priv->column_drag_info = NULL;
9745       return;
9746     }
9747   /* We fill in the ranges for the columns, now that we've isolated them */
9748   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9749
9750   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9751     {
9752       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9753
9754       reorder->left_align = left;
9755       if (tmp_list->next != NULL)
9756         {
9757           GtkAllocation right_allocation, left_allocation;
9758           GtkWidget    *left_button, *right_button;
9759
9760           g_assert (tmp_list->next->data);
9761
9762           right_button = gtk_tree_view_column_get_button (reorder->right_column);
9763           left_button  = gtk_tree_view_column_get_button
9764             (((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column);
9765
9766           gtk_widget_get_allocation (right_button, &right_allocation);
9767           gtk_widget_get_allocation (left_button, &left_allocation);
9768           left = reorder->right_align = (right_allocation.x + right_allocation.width + left_allocation.x) / 2;
9769         }
9770       else
9771         {
9772           reorder->right_align = gdk_window_get_width (tree_view->priv->header_window)
9773                                  + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9774         }
9775     }
9776 }
9777
9778 void
9779 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9780                                   GtkTreeViewColumn *column,
9781                                   GdkDevice         *device)
9782 {
9783   GdkEvent *send_event;
9784   GtkAllocation allocation;
9785   GtkAllocation button_allocation;
9786   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9787   GtkWidget *button;
9788   GdkDevice *pointer, *keyboard;
9789   GdkWindowAttr attributes;
9790   guint attributes_mask;
9791
9792   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9793   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9794   g_return_if_fail (tree_view->priv->drag_window == NULL);
9795
9796   gtk_tree_view_set_column_drag_info (tree_view, column);
9797
9798   if (tree_view->priv->column_drag_info == NULL)
9799     return;
9800
9801   button = gtk_tree_view_column_get_button (column);
9802
9803   gtk_widget_get_allocation (button, &button_allocation);
9804
9805   attributes.window_type = GDK_WINDOW_CHILD;
9806   attributes.wclass = GDK_INPUT_OUTPUT;
9807   attributes.x = button_allocation.x;
9808   attributes.y = 0;
9809   attributes.width = button_allocation.width;
9810   attributes.height = button_allocation.height;
9811   attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9812   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9813   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
9814
9815   tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
9816                                                  &attributes,
9817                                                  attributes_mask);
9818   gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
9819
9820   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
9821     {
9822       keyboard = device;
9823       pointer = gdk_device_get_associated_device (device);
9824     }
9825   else
9826     {
9827       pointer = device;
9828       keyboard = gdk_device_get_associated_device (device);
9829     }
9830
9831   gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
9832   gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);
9833
9834   gtk_grab_remove (button);
9835
9836   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9837   send_event->crossing.send_event = TRUE;
9838   send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (button)));
9839   send_event->crossing.subwindow = NULL;
9840   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9841   send_event->crossing.time = GDK_CURRENT_TIME;
9842   gdk_event_set_device (send_event, device);
9843
9844   gtk_propagate_event (button, send_event);
9845   gdk_event_free (send_event);
9846
9847   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9848   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9849   send_event->button.send_event = TRUE;
9850   send_event->button.time = GDK_CURRENT_TIME;
9851   send_event->button.x = -1;
9852   send_event->button.y = -1;
9853   send_event->button.axes = NULL;
9854   send_event->button.state = 0;
9855   send_event->button.button = GDK_BUTTON_PRIMARY;
9856   send_event->button.x_root = 0;
9857   send_event->button.y_root = 0;
9858   gdk_event_set_device (send_event, device);
9859
9860   gtk_propagate_event (button, send_event);
9861   gdk_event_free (send_event);
9862
9863   /* Kids, don't try this at home */
9864   g_object_ref (button);
9865   gtk_container_remove (GTK_CONTAINER (tree_view), button);
9866   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9867   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
9868   g_object_unref (button);
9869
9870   gtk_widget_get_allocation (button, &button_allocation);
9871   tree_view->priv->drag_column_x = button_allocation.x;
9872   allocation = button_allocation;
9873   allocation.x = 0;
9874   gtk_widget_size_allocate (button, &allocation);
9875   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9876
9877   tree_view->priv->drag_column = column;
9878   gdk_window_show (tree_view->priv->drag_window);
9879
9880   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9881   while (gtk_events_pending ())
9882     gtk_main_iteration ();
9883
9884   tree_view->priv->in_column_drag = TRUE;
9885
9886   gdk_device_grab (pointer,
9887                    tree_view->priv->drag_window,
9888                    GDK_OWNERSHIP_NONE,
9889                    FALSE,
9890                    GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9891                    NULL,
9892                    GDK_CURRENT_TIME);
9893   gdk_device_grab (keyboard,
9894                    tree_view->priv->drag_window,
9895                    GDK_OWNERSHIP_NONE,
9896                    FALSE,
9897                    GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
9898                    NULL,
9899                    GDK_CURRENT_TIME);
9900 }
9901
9902 static void
9903 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9904                                 GtkRBTree          *tree,
9905                                 GtkRBNode          *node)
9906 {
9907   GtkAllocation allocation;
9908   GdkRectangle rect;
9909
9910   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9911     return;
9912
9913   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9914   rect.x = 0;
9915   rect.width = gtk_tree_view_get_expander_size (tree_view);
9916   rect.width = MAX (rect.width, MAX (tree_view->priv->width, allocation.width));
9917
9918   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9919   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9920
9921   gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9922 }
9923
9924 void
9925 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9926                                 GtkRBTree          *tree,
9927                                 GtkRBNode          *node,
9928                                 const GdkRectangle *clip_rect)
9929 {
9930   GtkAllocation allocation;
9931   GdkRectangle rect;
9932
9933   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9934     return;
9935
9936   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9937   rect.x = 0;
9938   rect.width = MAX (tree_view->priv->width, allocation.width);
9939
9940   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9941   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9942
9943   if (clip_rect)
9944     {
9945       GdkRectangle new_rect;
9946
9947       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9948
9949       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9950     }
9951   else
9952     {
9953       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9954     }
9955 }
9956
9957 static inline gint
9958 gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view)
9959 {
9960   if (tree_view->priv->headers_visible)
9961     return tree_view->priv->header_height;
9962   /* else */
9963   return 0;
9964 }
9965
9966 gint
9967 _gtk_tree_view_get_header_height (GtkTreeView *tree_view)
9968 {
9969   return tree_view->priv->header_height;
9970 }
9971
9972 void
9973 _gtk_tree_view_get_row_separator_func (GtkTreeView                 *tree_view,
9974                                        GtkTreeViewRowSeparatorFunc *func,
9975                                        gpointer                    *data)
9976 {
9977   *func = tree_view->priv->row_separator_func;
9978   *data = tree_view->priv->row_separator_data;
9979 }
9980
9981 GtkTreePath *
9982 _gtk_tree_view_get_anchor_path (GtkTreeView *tree_view)
9983 {
9984   if (tree_view->priv->anchor)
9985     return gtk_tree_row_reference_get_path (tree_view->priv->anchor);
9986
9987   return NULL;
9988 }
9989
9990 void
9991 _gtk_tree_view_set_anchor_path (GtkTreeView *tree_view,
9992                                 GtkTreePath *anchor_path)
9993 {
9994   if (tree_view->priv->anchor)
9995     {
9996       gtk_tree_row_reference_free (tree_view->priv->anchor);
9997       tree_view->priv->anchor = NULL;
9998     }
9999
10000   if (anchor_path && tree_view->priv->model)
10001     tree_view->priv->anchor =
10002       gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
10003                                         tree_view->priv->model, anchor_path);
10004 }
10005
10006 GtkRBTree *
10007 _gtk_tree_view_get_rbtree (GtkTreeView *tree_view)
10008 {
10009   return tree_view->priv->tree;
10010 }
10011
10012 gboolean
10013 _gtk_tree_view_get_cursor_node (GtkTreeView  *tree_view,
10014                                 GtkRBTree   **tree,
10015                                 GtkRBNode   **node)
10016 {
10017   GtkTreeViewPrivate *priv;
10018
10019   priv = tree_view->priv;
10020
10021   if (priv->cursor_node == NULL)
10022     return FALSE;
10023
10024   *tree = priv->cursor_tree;
10025   *node = priv->cursor_node;
10026
10027   return TRUE;
10028 }
10029
10030 GdkWindow *
10031 _gtk_tree_view_get_header_window (GtkTreeView *tree_view)
10032 {
10033   return tree_view->priv->header_window;
10034 }
10035
10036 GtkTreeViewColumn *
10037 _gtk_tree_view_get_focus_column (GtkTreeView *tree_view)
10038 {
10039   return tree_view->priv->focus_column;
10040 }
10041
10042 void
10043 _gtk_tree_view_set_focus_column (GtkTreeView       *tree_view,
10044                                  GtkTreeViewColumn *column)
10045 {
10046   GtkTreeViewColumn *old_column = tree_view->priv->focus_column;
10047
10048   if (old_column == column)
10049     return;
10050
10051   tree_view->priv->focus_column = column;
10052
10053   _gtk_tree_view_accessible_update_focus_column (tree_view,
10054                                                  old_column,
10055                                                  column);
10056 }
10057
10058
10059 static void
10060 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
10061                                GtkTreePath        *path,
10062                                const GdkRectangle *clip_rect)
10063 {
10064   GtkRBTree *tree = NULL;
10065   GtkRBNode *node = NULL;
10066
10067   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
10068
10069   if (tree)
10070     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
10071 }
10072
10073 /* x and y are the mouse position
10074  */
10075 static void
10076 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
10077                           cairo_t     *cr,
10078                           GtkRBTree   *tree,
10079                           GtkRBNode   *node)
10080 {
10081   GdkRectangle area;
10082   GtkStateFlags state = 0;
10083   GtkStyleContext *context;
10084   GtkWidget *widget;
10085   gint x_offset = 0;
10086   gint x2;
10087   gint vertical_separator;
10088   gint expander_size;
10089   GtkCellRendererState flags = 0;
10090
10091   widget = GTK_WIDGET (tree_view);
10092   context = gtk_widget_get_style_context (widget);
10093
10094   gtk_widget_style_get (widget,
10095                         "vertical-separator", &vertical_separator,
10096                         NULL);
10097   expander_size = gtk_tree_view_get_expander_size (tree_view) - EXPANDER_EXTRA_PADDING;
10098
10099   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
10100     return;
10101
10102   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
10103
10104   area.x = x_offset;
10105   area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
10106                                                  vertical_separator);
10107   area.width = expander_size;
10108   area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
10109                                                     vertical_separator);
10110
10111   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
10112     flags |= GTK_CELL_RENDERER_SELECTED;
10113
10114   if (node == tree_view->priv->prelight_node &&
10115       tree_view->priv->arrow_prelit)
10116     flags |= GTK_CELL_RENDERER_PRELIT;
10117
10118   state = gtk_cell_renderer_get_state (NULL, widget, flags);
10119
10120   if (node->children != NULL)
10121     state |= GTK_STATE_FLAG_ACTIVE;
10122   else
10123     state &= ~(GTK_STATE_FLAG_ACTIVE);
10124
10125   gtk_style_context_save (context);
10126
10127   gtk_style_context_set_state (context, state);
10128   gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
10129
10130   gtk_render_expander (context, cr,
10131                        area.x, area.y,
10132                        area.width, area.height);
10133
10134   gtk_style_context_restore (context);
10135 }
10136
10137 static void
10138 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
10139
10140 {
10141   GtkTreePath *cursor_path;
10142
10143   if ((tree_view->priv->tree == NULL) ||
10144       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
10145     return;
10146
10147   cursor_path = NULL;
10148   if (tree_view->priv->cursor_node)
10149     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10150                                                   tree_view->priv->cursor_node);
10151
10152   if (cursor_path == NULL)
10153     {
10154       /* Consult the selection before defaulting to the
10155        * first focusable element
10156        */
10157       GList *selected_rows;
10158       GtkTreeModel *model;
10159       GtkTreeSelection *selection;
10160
10161       selection = gtk_tree_view_get_selection (tree_view);
10162       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
10163
10164       if (selected_rows)
10165         {
10166           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
10167           g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free);
10168         }
10169       else
10170         {
10171           cursor_path = gtk_tree_path_new_first ();
10172           search_first_focusable_path (tree_view, &cursor_path,
10173                                        TRUE, NULL, NULL);
10174         }
10175
10176       if (cursor_path)
10177         {
10178           if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
10179             gtk_tree_view_real_set_cursor (tree_view, cursor_path, 0);
10180           else
10181             gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10182         }
10183     }
10184
10185   if (cursor_path)
10186     {
10187       tree_view->priv->draw_keyfocus = TRUE;
10188
10189       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10190       gtk_tree_path_free (cursor_path);
10191
10192       if (tree_view->priv->focus_column == NULL)
10193         {
10194           GList *list;
10195           for (list = tree_view->priv->columns; list; list = list->next)
10196             {
10197               if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
10198                 {
10199                   GtkCellArea *cell_area;
10200
10201                   _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
10202
10203                   /* This happens when the treeview initially grabs focus and there
10204                    * is no column in focus, here we explicitly focus into the first cell */
10205                   cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10206                   if (!gtk_cell_area_get_focus_cell (cell_area))
10207                     {
10208                       gboolean rtl;
10209
10210                       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10211                       gtk_cell_area_focus (cell_area,
10212                                            rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
10213                     }
10214
10215                   break;
10216                 }
10217             }
10218         }
10219     }
10220 }
10221
10222 static void
10223 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
10224                                    gint         count)
10225 {
10226   gint selection_count;
10227   GtkRBTree *new_cursor_tree = NULL;
10228   GtkRBNode *new_cursor_node = NULL;
10229   GtkTreePath *cursor_path = NULL;
10230   gboolean grab_focus = TRUE;
10231   gboolean selectable;
10232   GtkDirectionType direction;
10233   GtkCellArea *cell_area = NULL;
10234   GtkCellRenderer *last_focus_cell = NULL;
10235   GtkTreeIter iter;
10236
10237   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10238     return;
10239
10240   if (tree_view->priv->cursor_node == NULL)
10241     return;
10242
10243   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10244                                                 tree_view->priv->cursor_node);
10245
10246   direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
10247
10248   if (tree_view->priv->focus_column)
10249     cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10250
10251   /* If focus stays in the area for this row, then just return for this round */
10252   if (cell_area && (count == -1 || count == 1) &&
10253       gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path))
10254     {
10255       gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
10256                                                tree_view->priv->model,
10257                                                &iter,
10258                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10259                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10260
10261       /* Save the last cell that had focus, if we hit the end of the view we'll give
10262        * focus back to it. */
10263       last_focus_cell = gtk_cell_area_get_focus_cell (cell_area);
10264
10265       /* If focus stays in the area, no need to change the cursor row */
10266       if (gtk_cell_area_focus (cell_area, direction))
10267         return;
10268     }
10269
10270   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
10271   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
10272                                                       tree_view->priv->cursor_node,
10273                                                       cursor_path);
10274
10275   if (selection_count == 0
10276       && gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE
10277       && !tree_view->priv->modify_selection_pressed
10278       && selectable)
10279     {
10280       /* Don't move the cursor, but just select the current node */
10281       new_cursor_tree = tree_view->priv->cursor_tree;
10282       new_cursor_node = tree_view->priv->cursor_node;
10283     }
10284   else
10285     {
10286       if (count == -1)
10287         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10288                                &new_cursor_tree, &new_cursor_node);
10289       else
10290         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10291                                &new_cursor_tree, &new_cursor_node);
10292     }
10293
10294   gtk_tree_path_free (cursor_path);
10295
10296   if (new_cursor_node)
10297     {
10298       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10299
10300       search_first_focusable_path (tree_view, &cursor_path,
10301                                    (count != -1),
10302                                    &new_cursor_tree,
10303                                    &new_cursor_node);
10304
10305       if (cursor_path)
10306         gtk_tree_path_free (cursor_path);
10307     }
10308
10309   /*
10310    * If the list has only one item and multi-selection is set then select
10311    * the row (if not yet selected).
10312    */
10313   if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE &&
10314       new_cursor_node == NULL)
10315     {
10316       if (count == -1)
10317         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10318                                &new_cursor_tree, &new_cursor_node);
10319       else
10320         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10321                                &new_cursor_tree, &new_cursor_node);
10322
10323       if (new_cursor_node == NULL
10324           && !GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
10325         {
10326           new_cursor_node = tree_view->priv->cursor_node;
10327           new_cursor_tree = tree_view->priv->cursor_tree;
10328         }
10329       else
10330         {
10331           new_cursor_tree = NULL;
10332           new_cursor_node = NULL;
10333         }
10334     }
10335
10336   if (new_cursor_node)
10337     {
10338       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10339       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10340       gtk_tree_path_free (cursor_path);
10341
10342       /* Give focus to the area in the new row */
10343       if (cell_area)
10344         gtk_cell_area_focus (cell_area, direction);
10345     }
10346   else
10347     {
10348       gtk_tree_view_clamp_node_visible (tree_view,
10349                                         tree_view->priv->cursor_tree,
10350                                         tree_view->priv->cursor_node);
10351
10352       if (!tree_view->priv->extend_selection_pressed)
10353         {
10354           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
10355                                           count < 0 ?
10356                                           GTK_DIR_UP : GTK_DIR_DOWN))
10357             {
10358               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10359
10360               if (toplevel)
10361                 gtk_widget_child_focus (toplevel,
10362                                         count < 0 ?
10363                                         GTK_DIR_TAB_BACKWARD :
10364                                         GTK_DIR_TAB_FORWARD);
10365
10366               grab_focus = FALSE;
10367             }
10368         }
10369       else
10370         {
10371           gtk_widget_error_bell (GTK_WIDGET (tree_view));
10372         }
10373
10374       if (cell_area)
10375         gtk_cell_area_set_focus_cell (cell_area, last_focus_cell);
10376     }
10377
10378   if (grab_focus)
10379     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10380 }
10381
10382 static void
10383 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
10384                                         gint         count)
10385 {
10386   GtkTreePath *old_cursor_path = NULL;
10387   GtkTreePath *cursor_path = NULL;
10388   GtkRBTree *start_cursor_tree = NULL;
10389   GtkRBNode *start_cursor_node = NULL;
10390   GtkRBTree *cursor_tree;
10391   GtkRBNode *cursor_node;
10392   gint y;
10393   gint window_y;
10394   gint vertical_separator;
10395
10396   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10397     return;
10398
10399   if (tree_view->priv->cursor_node == NULL)
10400     return;
10401
10402   old_cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10403                                                     tree_view->priv->cursor_node);
10404
10405   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
10406
10407   y = _gtk_rbtree_node_find_offset (tree_view->priv->cursor_tree, tree_view->priv->cursor_node);
10408   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
10409   y += tree_view->priv->cursor_offset;
10410   y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
10411   y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment),  (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
10412
10413   if (y >= tree_view->priv->height)
10414     y = tree_view->priv->height - 1;
10415
10416   tree_view->priv->cursor_offset =
10417     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
10418                              &cursor_tree, &cursor_node);
10419
10420   if (cursor_tree == NULL)
10421     {
10422       /* FIXME: we lost the cursor.  Should we try to get one? */
10423       gtk_tree_path_free (old_cursor_path);
10424       return;
10425     }
10426
10427   if (tree_view->priv->cursor_offset
10428       > gtk_tree_view_get_row_height (tree_view, cursor_node))
10429     {
10430       _gtk_rbtree_next_full (cursor_tree, cursor_node,
10431                              &cursor_tree, &cursor_node);
10432       tree_view->priv->cursor_offset -= gtk_tree_view_get_row_height (tree_view, cursor_node);
10433     }
10434
10435   y -= tree_view->priv->cursor_offset;
10436   cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10437
10438   start_cursor_tree = cursor_tree;
10439   start_cursor_node = cursor_node;
10440
10441   if (! search_first_focusable_path (tree_view, &cursor_path,
10442                                      (count != -1),
10443                                      &cursor_tree, &cursor_node))
10444     {
10445       /* It looks like we reached the end of the view without finding
10446        * a focusable row.  We will step backwards to find the last
10447        * focusable row.
10448        */
10449       cursor_tree = start_cursor_tree;
10450       cursor_node = start_cursor_node;
10451       cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10452
10453       search_first_focusable_path (tree_view, &cursor_path,
10454                                    (count == -1),
10455                                    &cursor_tree, &cursor_node);
10456     }
10457
10458   if (!cursor_path)
10459     goto cleanup;
10460
10461   /* update y */
10462   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10463
10464   gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10465
10466   y -= window_y;
10467   gtk_tree_view_scroll_to_point (tree_view, -1, y);
10468   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10469   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10470
10471   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
10472     gtk_widget_error_bell (GTK_WIDGET (tree_view));
10473
10474   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10475
10476 cleanup:
10477   gtk_tree_path_free (old_cursor_path);
10478   gtk_tree_path_free (cursor_path);
10479 }
10480
10481 static void
10482 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
10483                                       gint         count)
10484 {
10485   GtkTreePath *cursor_path = NULL;
10486   GtkTreeViewColumn *column;
10487   GtkTreeIter iter;
10488   GList *list;
10489   gboolean found_column = FALSE;
10490   gboolean rtl;
10491   GtkDirectionType direction;
10492   GtkCellArea     *cell_area;
10493   GtkCellRenderer *last_focus_cell = NULL;
10494   GtkCellArea     *last_focus_area = NULL;
10495
10496   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10497
10498   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10499     return;
10500
10501   if (tree_view->priv->cursor_node == NULL)
10502     return;
10503
10504   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10505                                                 tree_view->priv->cursor_node);
10506
10507   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
10508     {
10509       gtk_tree_path_free (cursor_path);
10510       return;
10511     }
10512   gtk_tree_path_free (cursor_path);
10513
10514   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
10515   if (tree_view->priv->focus_column)
10516     {
10517       /* Save the cell/area we are moving focus from, if moving the cursor
10518        * by one step hits the end we'll set focus back here */
10519       last_focus_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10520       last_focus_cell = gtk_cell_area_get_focus_cell (last_focus_area);
10521
10522       for (; list; list = (rtl ? list->prev : list->next))
10523         {
10524           if (list->data == tree_view->priv->focus_column)
10525             break;
10526         }
10527     }
10528
10529   direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
10530
10531   while (list)
10532     {
10533       column = list->data;
10534       if (gtk_tree_view_column_get_visible (column) == FALSE)
10535         goto loop_end;
10536
10537       gtk_tree_view_column_cell_set_cell_data (column,
10538                                                tree_view->priv->model,
10539                                                &iter,
10540                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10541                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10542
10543       cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
10544       if (gtk_cell_area_focus (cell_area, direction))
10545         {
10546           _gtk_tree_view_set_focus_column (tree_view, column);
10547           found_column = TRUE;
10548           break;
10549         }
10550
10551     loop_end:
10552       if (count == 1)
10553         list = rtl ? list->prev : list->next;
10554       else
10555         list = rtl ? list->next : list->prev;
10556     }
10557
10558   if (found_column)
10559     {
10560       if (!gtk_tree_view_has_can_focus_cell (tree_view))
10561         _gtk_tree_view_queue_draw_node (tree_view,
10562                                         tree_view->priv->cursor_tree,
10563                                         tree_view->priv->cursor_node,
10564                                         NULL);
10565       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
10566       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10567     }
10568   else
10569     {
10570       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10571
10572       if (last_focus_area)
10573         gtk_cell_area_set_focus_cell (last_focus_area, last_focus_cell);
10574     }
10575
10576   gtk_tree_view_clamp_column_visible (tree_view,
10577                                       tree_view->priv->focus_column, TRUE);
10578 }
10579
10580 static void
10581 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
10582                                      gint         count)
10583 {
10584   GtkRBTree *cursor_tree;
10585   GtkRBNode *cursor_node;
10586   GtkTreePath *path;
10587   GtkTreePath *old_path;
10588
10589   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10590     return;
10591
10592   g_return_if_fail (tree_view->priv->tree != NULL);
10593
10594   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
10595
10596   cursor_tree = tree_view->priv->tree;
10597
10598   if (count == -1)
10599     {
10600       cursor_node = _gtk_rbtree_first (cursor_tree);
10601
10602       /* Now go forward to find the first focusable row. */
10603       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10604       search_first_focusable_path (tree_view, &path,
10605                                    TRUE, &cursor_tree, &cursor_node);
10606     }
10607   else
10608     {
10609       cursor_node = cursor_tree->root;
10610
10611       do
10612         {
10613           while (cursor_node && !_gtk_rbtree_is_nil (cursor_node->right))
10614             cursor_node = cursor_node->right;
10615           if (cursor_node->children == NULL)
10616             break;
10617
10618           cursor_tree = cursor_node->children;
10619           cursor_node = cursor_tree->root;
10620         }
10621       while (1);
10622
10623       /* Now go backwards to find last focusable row. */
10624       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10625       search_first_focusable_path (tree_view, &path,
10626                                    FALSE, &cursor_tree, &cursor_node);
10627     }
10628
10629   if (!path)
10630     goto cleanup;
10631
10632   if (gtk_tree_path_compare (old_path, path))
10633     {
10634       gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
10635       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10636     }
10637   else
10638     {
10639       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10640     }
10641
10642 cleanup:
10643   gtk_tree_path_free (old_path);
10644   gtk_tree_path_free (path);
10645 }
10646
10647 static gboolean
10648 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10649 {
10650   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10651     return FALSE;
10652
10653   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10654     return FALSE;
10655
10656   gtk_tree_selection_select_all (tree_view->priv->selection);
10657
10658   return TRUE;
10659 }
10660
10661 static gboolean
10662 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
10663 {
10664   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10665     return FALSE;
10666
10667   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10668     return FALSE;
10669
10670   gtk_tree_selection_unselect_all (tree_view->priv->selection);
10671
10672   return TRUE;
10673 }
10674
10675 static gboolean
10676 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10677                                       gboolean     start_editing)
10678 {
10679   GtkRBTree *new_tree = NULL;
10680   GtkRBNode *new_node = NULL;
10681   GtkRBTree *cursor_tree = NULL;
10682   GtkRBNode *cursor_node = NULL;
10683   GtkTreePath *cursor_path = NULL;
10684   GtkTreeSelectMode mode = 0;
10685
10686   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10687     return FALSE;
10688
10689   if (tree_view->priv->cursor_node == NULL)
10690     return FALSE;
10691
10692   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10693                                                 tree_view->priv->cursor_node);
10694
10695   _gtk_tree_view_find_node (tree_view, cursor_path,
10696                             &cursor_tree, &cursor_node);
10697
10698   if (cursor_tree == NULL)
10699     {
10700       gtk_tree_path_free (cursor_path);
10701       return FALSE;
10702     }
10703
10704   if (!tree_view->priv->extend_selection_pressed && start_editing &&
10705       tree_view->priv->focus_column)
10706     {
10707       if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE))
10708         {
10709           gtk_tree_path_free (cursor_path);
10710           return TRUE;
10711         }
10712     }
10713
10714   if (tree_view->priv->modify_selection_pressed)
10715     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10716   if (tree_view->priv->extend_selection_pressed)
10717     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10718
10719   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10720                                             cursor_node,
10721                                             cursor_tree,
10722                                             cursor_path,
10723                                             mode,
10724                                             FALSE);
10725
10726   /* We bail out if the original (tree, node) don't exist anymore after
10727    * handling the selection-changed callback.  We do return TRUE because
10728    * the key press has been handled at this point.
10729    */
10730   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10731
10732   if (cursor_tree != new_tree || cursor_node != new_node)
10733     return FALSE;
10734
10735   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10736
10737   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10738   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10739
10740   if (!tree_view->priv->extend_selection_pressed)
10741     gtk_tree_view_row_activated (tree_view, cursor_path,
10742                                  tree_view->priv->focus_column);
10743
10744   gtk_tree_path_free (cursor_path);
10745
10746   return TRUE;
10747 }
10748
10749 static gboolean
10750 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10751 {
10752   GtkRBTree *new_tree = NULL;
10753   GtkRBNode *new_node = NULL;
10754   GtkTreePath *cursor_path = NULL;
10755
10756   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10757     return FALSE;
10758
10759   if (tree_view->priv->cursor_node == NULL)
10760     return FALSE;
10761
10762   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10763                                                 tree_view->priv->cursor_node);
10764
10765   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10766                                             tree_view->priv->cursor_node,
10767                                             tree_view->priv->cursor_tree,
10768                                             cursor_path,
10769                                             GTK_TREE_SELECT_MODE_TOGGLE,
10770                                             FALSE);
10771
10772   /* We bail out if the original (tree, node) don't exist anymore after
10773    * handling the selection-changed callback.  We do return TRUE because
10774    * the key press has been handled at this point.
10775    */
10776   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10777
10778   if (tree_view->priv->cursor_node != new_node)
10779     return FALSE;
10780
10781   gtk_tree_view_clamp_node_visible (tree_view,
10782                                     tree_view->priv->cursor_tree,
10783                                     tree_view->priv->cursor_node);
10784
10785   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10786   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10787   gtk_tree_path_free (cursor_path);
10788
10789   return TRUE;
10790 }
10791
10792 static gboolean
10793 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10794                                                gboolean     logical,
10795                                                gboolean     expand,
10796                                                gboolean     open_all)
10797 {
10798   GtkTreePath *cursor_path = NULL;
10799
10800   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10801     return FALSE;
10802
10803   if (tree_view->priv->cursor_node == NULL)
10804     return FALSE;
10805
10806   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10807                                                 tree_view->priv->cursor_node);
10808
10809   /* Don't handle the event if we aren't an expander */
10810   if (!GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT))
10811     return FALSE;
10812
10813   if (!logical
10814       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10815     expand = !expand;
10816
10817   if (expand)
10818     gtk_tree_view_real_expand_row (tree_view,
10819                                    cursor_path,
10820                                    tree_view->priv->cursor_tree,
10821                                    tree_view->priv->cursor_node,
10822                                    open_all,
10823                                    TRUE);
10824   else
10825     gtk_tree_view_real_collapse_row (tree_view,
10826                                      cursor_path,
10827                                      tree_view->priv->cursor_tree,
10828                                      tree_view->priv->cursor_node,
10829                                      TRUE);
10830
10831   gtk_tree_path_free (cursor_path);
10832
10833   return TRUE;
10834 }
10835
10836 static gboolean
10837 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10838 {
10839   GtkTreePath *cursor_path = NULL;
10840   GdkModifierType state;
10841
10842   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10843     goto out;
10844
10845   if (tree_view->priv->cursor_node == NULL)
10846     goto out;
10847
10848   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10849                                                 tree_view->priv->cursor_node);
10850
10851   if (tree_view->priv->cursor_tree->parent_node)
10852     {
10853       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10854
10855       gtk_tree_path_up (cursor_path);
10856
10857       if (gtk_get_current_event_state (&state))
10858         {
10859           GdkModifierType modify_mod_mask;
10860
10861           modify_mod_mask =
10862             gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
10863                                           GDK_MODIFIER_INTENT_MODIFY_SELECTION);
10864
10865           if ((state & modify_mod_mask) == modify_mod_mask)
10866             tree_view->priv->modify_selection_pressed = TRUE;
10867         }
10868
10869       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10870       gtk_tree_path_free (cursor_path);
10871
10872       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10873
10874       tree_view->priv->modify_selection_pressed = FALSE;
10875
10876       return TRUE;
10877     }
10878
10879  out:
10880
10881   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10882   return FALSE;
10883 }
10884
10885 static gboolean
10886 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10887 {
10888   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
10889   tree_view->priv->typeselect_flush_timeout = 0;
10890
10891   return FALSE;
10892 }
10893
10894 /* Cut and paste from gtkwindow.c */
10895 static void
10896 send_focus_change (GtkWidget *widget,
10897                    GdkDevice *device,
10898                    gboolean   in)
10899 {
10900   GdkDeviceManager *device_manager;
10901   GList *devices, *d;
10902
10903   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
10904   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
10905   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
10906   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
10907
10908   for (d = devices; d; d = d->next)
10909     {
10910       GdkDevice *dev = d->data;
10911       GdkEvent *fevent;
10912       GdkWindow *window;
10913
10914       if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
10915         continue;
10916
10917       window = gtk_widget_get_window (widget);
10918
10919       /* Skip non-master keyboards that haven't
10920        * selected for events from this window
10921        */
10922       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
10923           !gdk_window_get_device_events (window, dev))
10924         continue;
10925
10926       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10927
10928       fevent->focus_change.type = GDK_FOCUS_CHANGE;
10929       fevent->focus_change.window = g_object_ref (window);
10930       fevent->focus_change.in = in;
10931       gdk_event_set_device (fevent, device);
10932
10933       gtk_widget_send_focus_change (widget, fevent);
10934
10935       gdk_event_free (fevent);
10936     }
10937
10938   g_list_free (devices);
10939 }
10940
10941 static void
10942 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10943 {
10944   GtkWidget *frame, *vbox, *toplevel;
10945   GdkScreen *screen;
10946
10947   if (tree_view->priv->search_custom_entry_set)
10948     return;
10949
10950   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10951   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10952
10953    if (tree_view->priv->search_window != NULL)
10954      {
10955        if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10956          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10957                                       GTK_WINDOW (tree_view->priv->search_window));
10958        else if (gtk_window_has_group (GTK_WINDOW (tree_view->priv->search_window)))
10959          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
10960                                          GTK_WINDOW (tree_view->priv->search_window));
10961
10962        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10963
10964        return;
10965      }
10966
10967   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10968   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10969
10970   if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10971     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10972                                  GTK_WINDOW (tree_view->priv->search_window));
10973
10974   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10975                             GDK_WINDOW_TYPE_HINT_UTILITY);
10976   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10977   g_signal_connect (tree_view->priv->search_window, "delete-event",
10978                     G_CALLBACK (gtk_tree_view_search_delete_event),
10979                     tree_view);
10980   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10981                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10982                     tree_view);
10983   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10984                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10985                     tree_view);
10986   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10987                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10988                     tree_view);
10989
10990   frame = gtk_frame_new (NULL);
10991   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10992   gtk_widget_show (frame);
10993   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10994
10995   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10996   gtk_widget_show (vbox);
10997   gtk_container_add (GTK_CONTAINER (frame), vbox);
10998   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
10999
11000   /* add entry */
11001   tree_view->priv->search_entry = gtk_entry_new ();
11002   gtk_widget_show (tree_view->priv->search_entry);
11003   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
11004                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
11005                     tree_view);
11006   g_signal_connect (tree_view->priv->search_entry,
11007                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
11008                     tree_view);
11009
11010   g_signal_connect (_gtk_entry_get_im_context (GTK_ENTRY (tree_view->priv->search_entry)),
11011                     "preedit-changed",
11012                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
11013                     tree_view);
11014
11015   gtk_container_add (GTK_CONTAINER (vbox),
11016                      tree_view->priv->search_entry);
11017
11018   gtk_widget_realize (tree_view->priv->search_entry);
11019 }
11020
11021 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
11022  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
11023  */
11024 static gboolean
11025 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
11026                                              GdkDevice   *device,
11027                                              gboolean     keybinding)
11028 {
11029   /* We only start interactive search if we have focus or the columns
11030    * have focus.  If one of our children have focus, we don't want to
11031    * start the search.
11032    */
11033   GList *list;
11034   gboolean found_focus = FALSE;
11035   GtkWidgetClass *entry_parent_class;
11036
11037   if (!tree_view->priv->enable_search && !keybinding)
11038     return FALSE;
11039
11040   if (tree_view->priv->search_custom_entry_set)
11041     return FALSE;
11042
11043   if (tree_view->priv->search_window != NULL &&
11044       gtk_widget_get_visible (tree_view->priv->search_window))
11045     return TRUE;
11046
11047   for (list = tree_view->priv->columns; list; list = list->next)
11048     {
11049       GtkTreeViewColumn *column;
11050       GtkWidget         *button;
11051
11052       column = list->data;
11053       if (!gtk_tree_view_column_get_visible (column))
11054         continue;
11055
11056       button = gtk_tree_view_column_get_button (column);
11057       if (gtk_widget_has_focus (button))
11058         {
11059           found_focus = TRUE;
11060           break;
11061         }
11062     }
11063
11064   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
11065     found_focus = TRUE;
11066
11067   if (!found_focus)
11068     return FALSE;
11069
11070   if (tree_view->priv->search_column < 0)
11071     return FALSE;
11072
11073   gtk_tree_view_ensure_interactive_directory (tree_view);
11074
11075   if (keybinding)
11076     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
11077
11078   /* done, show it */
11079   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
11080   gtk_widget_show (tree_view->priv->search_window);
11081   if (tree_view->priv->search_entry_changed_id == 0)
11082     {
11083       tree_view->priv->search_entry_changed_id =
11084         g_signal_connect (tree_view->priv->search_entry, "changed",
11085                           G_CALLBACK (gtk_tree_view_search_init),
11086                           tree_view);
11087     }
11088
11089   tree_view->priv->typeselect_flush_timeout =
11090     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
11091                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
11092                    tree_view);
11093
11094   /* Grab focus will select all the text.  We don't want that to happen, so we
11095    * call the parent instance and bypass the selection change.  This is probably
11096    * really non-kosher. */
11097   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
11098   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
11099
11100   /* send focus-in event */
11101   send_focus_change (tree_view->priv->search_entry, device, TRUE);
11102
11103   /* search first matching iter */
11104   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
11105
11106   return TRUE;
11107 }
11108
11109 static gboolean
11110 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
11111 {
11112   return gtk_tree_view_real_start_interactive_search (tree_view,
11113                                                       gtk_get_current_event_device (),
11114                                                       TRUE);
11115 }
11116
11117 /* this function returns the new width of the column being resized given
11118  * the column and x position of the cursor; the x cursor position is passed
11119  * in as a pointer and automagicly corrected if it's beyond min/max limits
11120  */
11121 static gint
11122 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
11123                                 gint       i,
11124                                 gint      *x)
11125 {
11126   GtkAllocation allocation;
11127   GtkTreeViewColumn *column;
11128   GtkRequisition button_req;
11129   gint max_width, min_width;
11130   gint width;
11131   gboolean rtl;
11132
11133   /* first translate the x position from widget->window
11134    * to clist->clist_window
11135    */
11136   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
11137   column = g_list_nth (tree_view->priv->columns, i)->data;
11138   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
11139   width = rtl ? (allocation.x + allocation.width - *x) : (*x - allocation.x);
11140
11141   /* Clamp down the value */
11142   min_width = gtk_tree_view_column_get_min_width (column);
11143   if (min_width == -1)
11144     {
11145       gtk_widget_get_preferred_size (gtk_tree_view_column_get_button (column), &button_req, NULL);
11146       width = MAX (button_req.width, width);
11147     }
11148   else
11149     width = MAX (min_width, width);
11150
11151   max_width = gtk_tree_view_column_get_max_width (column);
11152   if (max_width != -1)
11153     width = MIN (width, max_width);
11154
11155   *x = rtl ? (allocation.x + allocation.width - width) : (allocation.x + width);
11156
11157   return width;
11158 }
11159
11160
11161 /* FIXME this adjust_allocation is a big cut-and-paste from
11162  * GtkCList, needs to be some "official" way to do this
11163  * factored out.
11164  */
11165 typedef struct
11166 {
11167   GdkWindow *window;
11168   int dx;
11169   int dy;
11170 } ScrollData;
11171
11172 /* The window to which widget->window is relative */
11173 #define ALLOCATION_WINDOW(widget)               \
11174    (!gtk_widget_get_has_window (widget) ?                   \
11175     gtk_widget_get_window (widget) :                        \
11176     gdk_window_get_parent (gtk_widget_get_window (widget)))
11177
11178 static void
11179 adjust_allocation_recurse (GtkWidget *widget,
11180                            gpointer   data)
11181 {
11182   GtkAllocation allocation;
11183   ScrollData *scroll_data = data;
11184
11185   /* Need to really size allocate instead of just poking
11186    * into widget->allocation if the widget is not realized.
11187    * FIXME someone figure out why this was.
11188    */
11189   gtk_widget_get_allocation (widget, &allocation);
11190   if (!gtk_widget_get_realized (widget))
11191     {
11192       if (gtk_widget_get_visible (widget))
11193         {
11194           GdkRectangle tmp_rectangle = allocation;
11195           tmp_rectangle.x += scroll_data->dx;
11196           tmp_rectangle.y += scroll_data->dy;
11197
11198           gtk_widget_size_allocate (widget, &tmp_rectangle);
11199         }
11200     }
11201   else
11202     {
11203       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
11204         {
11205           allocation.x += scroll_data->dx;
11206           allocation.y += scroll_data->dy;
11207           gtk_widget_set_allocation (widget, &allocation);
11208
11209           if (GTK_IS_CONTAINER (widget))
11210             gtk_container_forall (GTK_CONTAINER (widget),
11211                                   adjust_allocation_recurse,
11212                                   data);
11213         }
11214     }
11215 }
11216
11217 static void
11218 adjust_allocation (GtkWidget *widget,
11219                    int        dx,
11220                    int        dy)
11221 {
11222   ScrollData scroll_data;
11223
11224   if (gtk_widget_get_realized (widget))
11225     scroll_data.window = ALLOCATION_WINDOW (widget);
11226   else
11227     scroll_data.window = NULL;
11228
11229   scroll_data.dx = dx;
11230   scroll_data.dy = dy;
11231
11232   adjust_allocation_recurse (widget, &scroll_data);
11233 }
11234
11235 /* Callbacks */
11236 static void
11237 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
11238                                   GtkTreeView   *tree_view)
11239 {
11240   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11241     {
11242       gint dy;
11243
11244       gdk_window_move (tree_view->priv->bin_window,
11245                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11246                        gtk_tree_view_get_effective_header_height (tree_view));
11247       gdk_window_move (tree_view->priv->header_window,
11248                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11249                        0);
11250       dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11251       if (dy)
11252         {
11253           update_prelight (tree_view,
11254                            tree_view->priv->event_last_x,
11255                            tree_view->priv->event_last_y - dy);
11256
11257           if (tree_view->priv->edited_column)
11258             {
11259               GList *list;
11260               GtkTreeViewChild *child = NULL;
11261               GtkCellEditable *edit_widget;
11262               GtkCellArea *area;
11263
11264               area        = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column));
11265               edit_widget = gtk_cell_area_get_edit_widget (area);
11266               if (GTK_IS_WIDGET (edit_widget))
11267                 {
11268                   adjust_allocation (GTK_WIDGET (edit_widget), 0, dy);
11269
11270                   for (list = tree_view->priv->children; list; list = list->next)
11271                     {
11272                       child = (GtkTreeViewChild *)list->data;
11273                       if (child->widget == GTK_WIDGET (edit_widget))
11274                         {
11275                           child->y += dy;
11276                           break;
11277                         }
11278                     }
11279                 }
11280             }
11281         }
11282       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
11283
11284       if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
11285         {
11286           /* update our dy and top_row */
11287           tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11288
11289           if (!tree_view->priv->in_top_row_to_dy)
11290             gtk_tree_view_dy_to_top_row (tree_view);
11291         }
11292     }
11293 }
11294
11295 \f
11296
11297 /* Public methods
11298  */
11299
11300 /**
11301  * gtk_tree_view_new:
11302  *
11303  * Creates a new #GtkTreeView widget.
11304  *
11305  * Return value: A newly created #GtkTreeView widget.
11306  **/
11307 GtkWidget *
11308 gtk_tree_view_new (void)
11309 {
11310   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
11311 }
11312
11313 /**
11314  * gtk_tree_view_new_with_model:
11315  * @model: the model.
11316  *
11317  * Creates a new #GtkTreeView widget with the model initialized to @model.
11318  *
11319  * Return value: A newly created #GtkTreeView widget.
11320  **/
11321 GtkWidget *
11322 gtk_tree_view_new_with_model (GtkTreeModel *model)
11323 {
11324   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
11325 }
11326
11327 /* Public Accessors
11328  */
11329
11330 /**
11331  * gtk_tree_view_get_model:
11332  * @tree_view: a #GtkTreeView
11333  *
11334  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
11335  * model is unset.
11336  *
11337  * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
11338  **/
11339 GtkTreeModel *
11340 gtk_tree_view_get_model (GtkTreeView *tree_view)
11341 {
11342   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11343
11344   return tree_view->priv->model;
11345 }
11346
11347 /**
11348  * gtk_tree_view_set_model:
11349  * @tree_view: A #GtkTreeView.
11350  * @model: (allow-none): The model.
11351  *
11352  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
11353  * set, it will remove it before setting the new model.  If @model is %NULL,
11354  * then it will unset the old model.
11355  **/
11356 void
11357 gtk_tree_view_set_model (GtkTreeView  *tree_view,
11358                          GtkTreeModel *model)
11359 {
11360   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11361   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
11362
11363   if (model == tree_view->priv->model)
11364     return;
11365
11366   if (tree_view->priv->scroll_to_path)
11367     {
11368       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11369       tree_view->priv->scroll_to_path = NULL;
11370     }
11371
11372   if (tree_view->priv->rubber_band_status)
11373     gtk_tree_view_stop_rubber_band (tree_view);
11374
11375   if (tree_view->priv->model)
11376     {
11377       GList *tmplist = tree_view->priv->columns;
11378
11379       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
11380       gtk_tree_view_stop_editing (tree_view, TRUE);
11381
11382       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11383                                             gtk_tree_view_row_changed,
11384                                             tree_view);
11385       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11386                                             gtk_tree_view_row_inserted,
11387                                             tree_view);
11388       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11389                                             gtk_tree_view_row_has_child_toggled,
11390                                             tree_view);
11391       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11392                                             gtk_tree_view_row_deleted,
11393                                             tree_view);
11394       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11395                                             gtk_tree_view_rows_reordered,
11396                                             tree_view);
11397
11398       for (; tmplist; tmplist = tmplist->next)
11399         _gtk_tree_view_column_unset_model (tmplist->data,
11400                                            tree_view->priv->model);
11401
11402       if (tree_view->priv->tree)
11403         gtk_tree_view_free_rbtree (tree_view);
11404
11405       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
11406       tree_view->priv->drag_dest_row = NULL;
11407       gtk_tree_row_reference_free (tree_view->priv->anchor);
11408       tree_view->priv->anchor = NULL;
11409       gtk_tree_row_reference_free (tree_view->priv->top_row);
11410       tree_view->priv->top_row = NULL;
11411       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11412       tree_view->priv->scroll_to_path = NULL;
11413
11414       tree_view->priv->scroll_to_column = NULL;
11415
11416       g_object_unref (tree_view->priv->model);
11417
11418       tree_view->priv->search_column = -1;
11419       tree_view->priv->fixed_height_check = 0;
11420       tree_view->priv->fixed_height = -1;
11421       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
11422       tree_view->priv->last_button_x = -1;
11423       tree_view->priv->last_button_y = -1;
11424     }
11425
11426   tree_view->priv->model = model;
11427
11428   if (tree_view->priv->model)
11429     {
11430       gint i;
11431       GtkTreePath *path;
11432       GtkTreeIter iter;
11433       GtkTreeModelFlags flags;
11434
11435       if (tree_view->priv->search_column == -1)
11436         {
11437           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
11438             {
11439               GType type = gtk_tree_model_get_column_type (model, i);
11440
11441               if (g_value_type_transformable (type, G_TYPE_STRING))
11442                 {
11443                   tree_view->priv->search_column = i;
11444                   break;
11445                 }
11446             }
11447         }
11448
11449       g_object_ref (tree_view->priv->model);
11450       g_signal_connect (tree_view->priv->model,
11451                         "row-changed",
11452                         G_CALLBACK (gtk_tree_view_row_changed),
11453                         tree_view);
11454       g_signal_connect (tree_view->priv->model,
11455                         "row-inserted",
11456                         G_CALLBACK (gtk_tree_view_row_inserted),
11457                         tree_view);
11458       g_signal_connect (tree_view->priv->model,
11459                         "row-has-child-toggled",
11460                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
11461                         tree_view);
11462       g_signal_connect (tree_view->priv->model,
11463                         "row-deleted",
11464                         G_CALLBACK (gtk_tree_view_row_deleted),
11465                         tree_view);
11466       g_signal_connect (tree_view->priv->model,
11467                         "rows-reordered",
11468                         G_CALLBACK (gtk_tree_view_rows_reordered),
11469                         tree_view);
11470
11471       flags = gtk_tree_model_get_flags (tree_view->priv->model);
11472       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
11473         tree_view->priv->is_list = TRUE;
11474       else
11475         tree_view->priv->is_list = FALSE;
11476
11477       path = gtk_tree_path_new_first ();
11478       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
11479         {
11480           tree_view->priv->tree = _gtk_rbtree_new ();
11481           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
11482           _gtk_tree_view_accessible_add (tree_view, tree_view->priv->tree, NULL);
11483         }
11484       gtk_tree_path_free (path);
11485
11486       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
11487       install_presize_handler (tree_view);
11488     }
11489
11490   gtk_tree_view_real_set_cursor (tree_view, NULL, CURSOR_INVALID);
11491
11492   g_object_notify (G_OBJECT (tree_view), "model");
11493
11494   if (tree_view->priv->selection)
11495   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
11496
11497   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11498     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11499 }
11500
11501 /**
11502  * gtk_tree_view_get_selection:
11503  * @tree_view: A #GtkTreeView.
11504  *
11505  * Gets the #GtkTreeSelection associated with @tree_view.
11506  *
11507  * Return value: (transfer none): A #GtkTreeSelection object.
11508  **/
11509 GtkTreeSelection *
11510 gtk_tree_view_get_selection (GtkTreeView *tree_view)
11511 {
11512   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11513
11514   return tree_view->priv->selection;
11515 }
11516
11517 /**
11518  * gtk_tree_view_get_hadjustment:
11519  * @tree_view: A #GtkTreeView
11520  *
11521  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
11522  *
11523  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11524  *     if none is currently being used.
11525  *
11526  * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment()
11527  **/
11528 GtkAdjustment *
11529 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
11530 {
11531   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11532
11533   return gtk_tree_view_do_get_hadjustment (tree_view);
11534 }
11535
11536 static GtkAdjustment *
11537 gtk_tree_view_do_get_hadjustment (GtkTreeView *tree_view)
11538 {
11539   return tree_view->priv->hadjustment;
11540 }
11541
11542 /**
11543  * gtk_tree_view_set_hadjustment:
11544  * @tree_view: A #GtkTreeView
11545  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11546  *
11547  * Sets the #GtkAdjustment for the current horizontal aspect.
11548  *
11549  * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment()
11550  **/
11551 void
11552 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
11553                                GtkAdjustment *adjustment)
11554 {
11555   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11556   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11557
11558   gtk_tree_view_do_set_hadjustment (tree_view, adjustment);
11559 }
11560
11561 static void
11562 gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
11563                                   GtkAdjustment *adjustment)
11564 {
11565   GtkTreeViewPrivate *priv = tree_view->priv;
11566
11567   if (adjustment && priv->hadjustment == adjustment)
11568     return;
11569
11570   if (priv->hadjustment != NULL)
11571     {
11572       g_signal_handlers_disconnect_by_func (priv->hadjustment,
11573                                             gtk_tree_view_adjustment_changed,
11574                                             tree_view);
11575       g_object_unref (priv->hadjustment);
11576     }
11577
11578   if (adjustment == NULL)
11579     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11580                                      0.0, 0.0, 0.0);
11581
11582   g_signal_connect (adjustment, "value-changed",
11583                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11584   priv->hadjustment = g_object_ref_sink (adjustment);
11585   /* FIXME: Adjustment should probably be populated here with fresh values, but
11586    * internal details are too complicated for me to decipher right now.
11587    */
11588   gtk_tree_view_adjustment_changed (NULL, tree_view);
11589
11590   g_object_notify (G_OBJECT (tree_view), "hadjustment");
11591 }
11592
11593 /**
11594  * gtk_tree_view_get_vadjustment:
11595  * @tree_view: A #GtkTreeView
11596  *
11597  * Gets the #GtkAdjustment currently being used for the vertical aspect.
11598  *
11599  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11600  *     if none is currently being used.
11601  *
11602  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
11603  **/
11604 GtkAdjustment *
11605 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
11606 {
11607   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11608
11609   return gtk_tree_view_do_get_vadjustment (tree_view);
11610 }
11611
11612 static GtkAdjustment *
11613 gtk_tree_view_do_get_vadjustment (GtkTreeView *tree_view)
11614 {
11615   return tree_view->priv->vadjustment;
11616 }
11617
11618 /**
11619  * gtk_tree_view_set_vadjustment:
11620  * @tree_view: A #GtkTreeView
11621  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11622  *
11623  * Sets the #GtkAdjustment for the current vertical aspect.
11624  *
11625  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
11626  **/
11627 void
11628 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
11629                                GtkAdjustment *adjustment)
11630 {
11631   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11632   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11633
11634   gtk_tree_view_do_set_vadjustment (tree_view, adjustment);
11635 }
11636
11637 static void
11638 gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
11639                                   GtkAdjustment *adjustment)
11640 {
11641   GtkTreeViewPrivate *priv = tree_view->priv;
11642
11643   if (adjustment && priv->vadjustment == adjustment)
11644     return;
11645
11646   if (priv->vadjustment != NULL)
11647     {
11648       g_signal_handlers_disconnect_by_func (priv->vadjustment,
11649                                             gtk_tree_view_adjustment_changed,
11650                                             tree_view);
11651       g_object_unref (priv->vadjustment);
11652     }
11653
11654   if (adjustment == NULL)
11655     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11656                                      0.0, 0.0, 0.0);
11657
11658   g_signal_connect (adjustment, "value-changed",
11659                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11660   priv->vadjustment = g_object_ref_sink (adjustment);
11661   /* FIXME: Adjustment should probably be populated here with fresh values, but
11662    * internal details are too complicated for me to decipher right now.
11663    */
11664   gtk_tree_view_adjustment_changed (NULL, tree_view);
11665   g_object_notify (G_OBJECT (tree_view), "vadjustment");
11666 }
11667
11668 /* Column and header operations */
11669
11670 /**
11671  * gtk_tree_view_get_headers_visible:
11672  * @tree_view: A #GtkTreeView.
11673  *
11674  * Returns %TRUE if the headers on the @tree_view are visible.
11675  *
11676  * Return value: Whether the headers are visible or not.
11677  **/
11678 gboolean
11679 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
11680 {
11681   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11682
11683   return tree_view->priv->headers_visible;
11684 }
11685
11686 /**
11687  * gtk_tree_view_set_headers_visible:
11688  * @tree_view: A #GtkTreeView.
11689  * @headers_visible: %TRUE if the headers are visible
11690  *
11691  * Sets the visibility state of the headers.
11692  **/
11693 void
11694 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
11695                                    gboolean     headers_visible)
11696 {
11697   gint x, y;
11698   GList *list;
11699   GtkTreeViewColumn *column;
11700   GtkAllocation allocation;
11701   GtkWidget *button;
11702
11703   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11704
11705   headers_visible = !! headers_visible;
11706
11707   if (tree_view->priv->headers_visible == headers_visible)
11708     return;
11709
11710   tree_view->priv->headers_visible = headers_visible == TRUE;
11711
11712   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11713     {
11714       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
11715       if (headers_visible)
11716         {
11717           gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11718           gdk_window_move_resize (tree_view->priv->bin_window,
11719                                   x, y  + gtk_tree_view_get_effective_header_height (tree_view),
11720                                   tree_view->priv->width, allocation.height -  + gtk_tree_view_get_effective_header_height (tree_view));
11721
11722           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
11723             gtk_tree_view_map_buttons (tree_view);
11724         }
11725       else
11726         {
11727           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
11728
11729           for (list = tree_view->priv->columns; list; list = list->next)
11730             {
11731               column = list->data;
11732               button = gtk_tree_view_column_get_button (column);
11733
11734               gtk_widget_hide (button);
11735               gtk_widget_unmap (button);
11736             }
11737           gdk_window_hide (tree_view->priv->header_window);
11738         }
11739     }
11740
11741   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11742   gtk_adjustment_configure (tree_view->priv->vadjustment,
11743                             gtk_adjustment_get_value (tree_view->priv->vadjustment),
11744                             0,
11745                             tree_view->priv->height,
11746                             gtk_adjustment_get_step_increment (tree_view->priv->vadjustment),
11747                             (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2,
11748                             allocation.height - gtk_tree_view_get_effective_header_height (tree_view));
11749
11750   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11751
11752   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11753 }
11754
11755 /**
11756  * gtk_tree_view_columns_autosize:
11757  * @tree_view: A #GtkTreeView.
11758  *
11759  * Resizes all columns to their optimal width. Only works after the
11760  * treeview has been realized.
11761  **/
11762 void
11763 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11764 {
11765   gboolean dirty = FALSE;
11766   GList *list;
11767   GtkTreeViewColumn *column;
11768
11769   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11770
11771   for (list = tree_view->priv->columns; list; list = list->next)
11772     {
11773       column = list->data;
11774       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11775         continue;
11776       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11777       dirty = TRUE;
11778     }
11779
11780   if (dirty)
11781     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11782 }
11783
11784 /**
11785  * gtk_tree_view_set_headers_clickable:
11786  * @tree_view: A #GtkTreeView.
11787  * @setting: %TRUE if the columns are clickable.
11788  *
11789  * Allow the column title buttons to be clicked.
11790  **/
11791 void
11792 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11793                                      gboolean   setting)
11794 {
11795   GList *list;
11796
11797   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11798
11799   for (list = tree_view->priv->columns; list; list = list->next)
11800     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11801
11802   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11803 }
11804
11805
11806 /**
11807  * gtk_tree_view_get_headers_clickable:
11808  * @tree_view: A #GtkTreeView.
11809  *
11810  * Returns whether all header columns are clickable.
11811  *
11812  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11813  *
11814  * Since: 2.10
11815  **/
11816 gboolean
11817 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11818 {
11819   GList *list;
11820
11821   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11822
11823   for (list = tree_view->priv->columns; list; list = list->next)
11824     if (!gtk_tree_view_column_get_clickable (GTK_TREE_VIEW_COLUMN (list->data)))
11825       return FALSE;
11826
11827   return TRUE;
11828 }
11829
11830 /**
11831  * gtk_tree_view_set_rules_hint:
11832  * @tree_view: a #GtkTreeView
11833  * @setting: %TRUE if the tree requires reading across rows
11834  *
11835  * This function tells GTK+ that the user interface for your
11836  * application requires users to read across tree rows and associate
11837  * cells with one another. By default, GTK+ will then render the tree
11838  * with alternating row colors. Do <emphasis>not</emphasis> use it
11839  * just because you prefer the appearance of the ruled tree; that's a
11840  * question for the theme. Some themes will draw tree rows in
11841  * alternating colors even when rules are turned off, and users who
11842  * prefer that appearance all the time can choose those themes. You
11843  * should call this function only as a <emphasis>semantic</emphasis>
11844  * hint to the theme engine that your tree makes alternating colors
11845  * useful from a functional standpoint (since it has lots of columns,
11846  * generally).
11847  *
11848  **/
11849 void
11850 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11851                               gboolean      setting)
11852 {
11853   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11854
11855   setting = setting != FALSE;
11856
11857   if (tree_view->priv->has_rules != setting)
11858     {
11859       tree_view->priv->has_rules = setting;
11860       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11861     }
11862
11863   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11864 }
11865
11866 /**
11867  * gtk_tree_view_get_rules_hint:
11868  * @tree_view: a #GtkTreeView
11869  *
11870  * Gets the setting set by gtk_tree_view_set_rules_hint().
11871  *
11872  * Return value: %TRUE if rules are useful for the user of this tree
11873  **/
11874 gboolean
11875 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11876 {
11877   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11878
11879   return tree_view->priv->has_rules;
11880 }
11881
11882 /* Public Column functions
11883  */
11884
11885 /**
11886  * gtk_tree_view_append_column:
11887  * @tree_view: A #GtkTreeView.
11888  * @column: The #GtkTreeViewColumn to add.
11889  *
11890  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11891  * mode enabled, then @column must have its "sizing" property set to be
11892  * GTK_TREE_VIEW_COLUMN_FIXED.
11893  *
11894  * Return value: The number of columns in @tree_view after appending.
11895  **/
11896 gint
11897 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11898                              GtkTreeViewColumn *column)
11899 {
11900   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11901   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11902   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11903
11904   return gtk_tree_view_insert_column (tree_view, column, -1);
11905 }
11906
11907 void
11908 _gtk_tree_view_reset_header_styles (GtkTreeView *tree_view)
11909 {
11910   GList *columns;
11911
11912   for (columns = tree_view->priv->columns; columns; columns = columns->next)
11913     {
11914       GtkTreeViewColumn *column = columns->data;
11915       GtkWidget *header_widget;
11916
11917       if (!gtk_tree_view_column_get_visible (column))
11918         continue;
11919
11920       header_widget = gtk_tree_view_column_get_widget (column);
11921
11922       if (!header_widget)
11923         header_widget = gtk_tree_view_column_get_button (column);
11924
11925       _gtk_widget_invalidate_style_context (header_widget, GTK_CSS_CHANGE_PARENT_REGION);
11926     }
11927 }
11928
11929
11930 /**
11931  * gtk_tree_view_remove_column:
11932  * @tree_view: A #GtkTreeView.
11933  * @column: The #GtkTreeViewColumn to remove.
11934  *
11935  * Removes @column from @tree_view.
11936  *
11937  * Return value: The number of columns in @tree_view after removing.
11938  **/
11939 gint
11940 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11941                              GtkTreeViewColumn *column)
11942 {
11943   guint position;
11944
11945   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11946   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11947   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1);
11948
11949   if (tree_view->priv->focus_column == column)
11950     _gtk_tree_view_set_focus_column (tree_view, NULL);
11951
11952   if (tree_view->priv->edited_column == column)
11953     {
11954       gtk_tree_view_stop_editing (tree_view, TRUE);
11955
11956       /* no need to, but just to be sure ... */
11957       tree_view->priv->edited_column = NULL;
11958     }
11959
11960   if (tree_view->priv->expander_column == column)
11961     tree_view->priv->expander_column = NULL;
11962
11963   g_signal_handlers_disconnect_by_func (column,
11964                                         G_CALLBACK (column_sizing_notify),
11965                                         tree_view);
11966
11967   _gtk_tree_view_column_unset_tree_view (column);
11968
11969   position = g_list_index (tree_view->priv->columns, column);
11970
11971   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11972   tree_view->priv->n_columns--;
11973
11974   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11975     {
11976       GList *list;
11977
11978       _gtk_tree_view_column_unrealize_button (column);
11979       for (list = tree_view->priv->columns; list; list = list->next)
11980         {
11981           GtkTreeViewColumn *tmp_column;
11982
11983           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11984           if (gtk_tree_view_column_get_visible (tmp_column))
11985             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
11986         }
11987
11988       if (tree_view->priv->n_columns == 0 &&
11989           gtk_tree_view_get_headers_visible (tree_view))
11990         gdk_window_hide (tree_view->priv->header_window);
11991
11992       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11993     }
11994
11995   _gtk_tree_view_reset_header_styles (tree_view);
11996
11997   _gtk_tree_view_accessible_remove_column (tree_view, column, position);
11998
11999   g_object_unref (column);
12000   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12001
12002   return tree_view->priv->n_columns;
12003 }
12004
12005 /**
12006  * gtk_tree_view_insert_column:
12007  * @tree_view: A #GtkTreeView.
12008  * @column: The #GtkTreeViewColumn to be inserted.
12009  * @position: The position to insert @column in.
12010  *
12011  * This inserts the @column into the @tree_view at @position.  If @position is
12012  * -1, then the column is inserted at the end. If @tree_view has
12013  * "fixed_height" mode enabled, then @column must have its "sizing" property
12014  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
12015  *
12016  * Return value: The number of columns in @tree_view after insertion.
12017  **/
12018 gint
12019 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
12020                              GtkTreeViewColumn *column,
12021                              gint               position)
12022 {
12023   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12024   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
12025   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
12026
12027   if (tree_view->priv->fixed_height_mode)
12028     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
12029                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
12030
12031   if (position < 0 || position > tree_view->priv->n_columns)
12032     position = tree_view->priv->n_columns;
12033
12034   g_object_ref_sink (column);
12035
12036   if (tree_view->priv->n_columns == 0 &&
12037       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
12038       gtk_tree_view_get_headers_visible (tree_view))
12039     {
12040       gdk_window_show (tree_view->priv->header_window);
12041     }
12042
12043   g_signal_connect (column, "notify::sizing",
12044                     G_CALLBACK (column_sizing_notify), tree_view);
12045
12046   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
12047                                             column, position);
12048   tree_view->priv->n_columns++;
12049
12050   _gtk_tree_view_column_set_tree_view (column, tree_view);
12051
12052   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12053     {
12054       GList *list;
12055
12056       _gtk_tree_view_column_realize_button (column);
12057
12058       for (list = tree_view->priv->columns; list; list = list->next)
12059         {
12060           column = GTK_TREE_VIEW_COLUMN (list->data);
12061           if (gtk_tree_view_column_get_visible (column))
12062             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12063         }
12064       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12065     }
12066
12067   _gtk_tree_view_reset_header_styles (tree_view);
12068
12069   _gtk_tree_view_accessible_add_column (tree_view, column, position);
12070
12071   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12072
12073   return tree_view->priv->n_columns;
12074 }
12075
12076 /**
12077  * gtk_tree_view_insert_column_with_attributes:
12078  * @tree_view: A #GtkTreeView
12079  * @position: The position to insert the new column in
12080  * @title: The title to set the header to
12081  * @cell: The #GtkCellRenderer
12082  * @...: A %NULL-terminated list of attributes
12083  *
12084  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
12085  * @position.  If @position is -1, then the newly created column is inserted at
12086  * the end.  The column is initialized with the attributes given. If @tree_view
12087  * has "fixed_height" mode enabled, then the new column will have its sizing
12088  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12089  *
12090  * Return value: The number of columns in @tree_view after insertion.
12091  **/
12092 gint
12093 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
12094                                              gint             position,
12095                                              const gchar     *title,
12096                                              GtkCellRenderer *cell,
12097                                              ...)
12098 {
12099   GtkTreeViewColumn *column;
12100   gchar *attribute;
12101   va_list args;
12102   gint column_id;
12103
12104   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12105
12106   column = gtk_tree_view_column_new ();
12107   if (tree_view->priv->fixed_height_mode)
12108     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12109
12110   gtk_tree_view_column_set_title (column, title);
12111   gtk_tree_view_column_pack_start (column, cell, TRUE);
12112
12113   va_start (args, cell);
12114
12115   attribute = va_arg (args, gchar *);
12116
12117   while (attribute != NULL)
12118     {
12119       column_id = va_arg (args, gint);
12120       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
12121       attribute = va_arg (args, gchar *);
12122     }
12123
12124   va_end (args);
12125
12126   return gtk_tree_view_insert_column (tree_view, column, position);
12127 }
12128
12129 /**
12130  * gtk_tree_view_insert_column_with_data_func:
12131  * @tree_view: a #GtkTreeView
12132  * @position: Position to insert, -1 for append
12133  * @title: column title
12134  * @cell: cell renderer for column
12135  * @func: function to set attributes of cell renderer
12136  * @data: data for @func
12137  * @dnotify: destroy notifier for @data
12138  *
12139  * Convenience function that inserts a new column into the #GtkTreeView
12140  * with the given cell renderer and a #GtkTreeCellDataFunc to set cell renderer
12141  * attributes (normally using data from the model). See also
12142  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
12143  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
12144  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12145  *
12146  * Return value: number of columns in the tree view post-insert
12147  **/
12148 gint
12149 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
12150                                              gint                       position,
12151                                              const gchar               *title,
12152                                              GtkCellRenderer           *cell,
12153                                              GtkTreeCellDataFunc        func,
12154                                              gpointer                   data,
12155                                              GDestroyNotify             dnotify)
12156 {
12157   GtkTreeViewColumn *column;
12158
12159   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12160
12161   column = gtk_tree_view_column_new ();
12162   if (tree_view->priv->fixed_height_mode)
12163     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12164
12165   gtk_tree_view_column_set_title (column, title);
12166   gtk_tree_view_column_pack_start (column, cell, TRUE);
12167   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
12168
12169   return gtk_tree_view_insert_column (tree_view, column, position);
12170 }
12171
12172 /**
12173  * gtk_tree_view_get_n_columns:
12174  * @tree_view: a #GtkTreeView
12175  *
12176  * Queries the number of columns in the given @tree_view.
12177  *
12178  * Returns: The number of columns in the @tree_view
12179  *
12180  * Since: 3.4
12181  **/
12182 guint
12183 gtk_tree_view_get_n_columns (GtkTreeView *tree_view)
12184 {
12185   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
12186
12187   return tree_view->priv->n_columns;
12188 }
12189
12190 /**
12191  * gtk_tree_view_get_column:
12192  * @tree_view: A #GtkTreeView.
12193  * @n: The position of the column, counting from 0.
12194  *
12195  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
12196  *
12197  * Return value: (transfer none): The #GtkTreeViewColumn, or %NULL if the
12198  *     position is outside the range of columns.
12199  **/
12200 GtkTreeViewColumn *
12201 gtk_tree_view_get_column (GtkTreeView *tree_view,
12202                           gint         n)
12203 {
12204   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12205
12206   if (n < 0 || n >= tree_view->priv->n_columns)
12207     return NULL;
12208
12209   if (tree_view->priv->columns == NULL)
12210     return NULL;
12211
12212   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
12213 }
12214
12215 /**
12216  * gtk_tree_view_get_columns:
12217  * @tree_view: A #GtkTreeView
12218  *
12219  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
12220  * The returned list must be freed with g_list_free ().
12221  *
12222  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
12223  **/
12224 GList *
12225 gtk_tree_view_get_columns (GtkTreeView *tree_view)
12226 {
12227   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12228
12229   return g_list_copy (tree_view->priv->columns);
12230 }
12231
12232 /**
12233  * gtk_tree_view_move_column_after:
12234  * @tree_view: A #GtkTreeView
12235  * @column: The #GtkTreeViewColumn to be moved.
12236  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
12237  *
12238  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
12239  * @column is placed in the first position.
12240  **/
12241 void
12242 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
12243                                  GtkTreeViewColumn *column,
12244                                  GtkTreeViewColumn *base_column)
12245 {
12246   GList *column_list_el, *base_el = NULL;
12247
12248   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12249
12250   column_list_el = g_list_find (tree_view->priv->columns, column);
12251   g_return_if_fail (column_list_el != NULL);
12252
12253   if (base_column)
12254     {
12255       base_el = g_list_find (tree_view->priv->columns, base_column);
12256       g_return_if_fail (base_el != NULL);
12257     }
12258
12259   if (column_list_el->prev == base_el)
12260     return;
12261
12262   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
12263   if (base_el == NULL)
12264     {
12265       column_list_el->prev = NULL;
12266       column_list_el->next = tree_view->priv->columns;
12267       if (column_list_el->next)
12268         column_list_el->next->prev = column_list_el;
12269       tree_view->priv->columns = column_list_el;
12270     }
12271   else
12272     {
12273       column_list_el->prev = base_el;
12274       column_list_el->next = base_el->next;
12275       if (column_list_el->next)
12276         column_list_el->next->prev = column_list_el;
12277       base_el->next = column_list_el;
12278     }
12279
12280   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12281     {
12282       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12283       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
12284     }
12285
12286   _gtk_tree_view_reset_header_styles (tree_view);
12287
12288   _gtk_tree_view_accessible_reorder_column (tree_view, column);
12289
12290   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12291 }
12292
12293 /**
12294  * gtk_tree_view_set_expander_column:
12295  * @tree_view: A #GtkTreeView
12296  * @column: %NULL, or the column to draw the expander arrow at.
12297  *
12298  * Sets the column to draw the expander arrow at. It must be in @tree_view.
12299  * If @column is %NULL, then the expander arrow is always at the first
12300  * visible column.
12301  *
12302  * If you do not want expander arrow to appear in your tree, set the
12303  * expander column to a hidden column.
12304  **/
12305 void
12306 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
12307                                    GtkTreeViewColumn *column)
12308 {
12309   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12310   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12311   g_return_if_fail (column == NULL || gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view));
12312
12313   if (tree_view->priv->expander_column != column)
12314     {
12315       tree_view->priv->expander_column = column;
12316       g_object_notify (G_OBJECT (tree_view), "expander-column");
12317     }
12318 }
12319
12320 /**
12321  * gtk_tree_view_get_expander_column:
12322  * @tree_view: A #GtkTreeView
12323  *
12324  * Returns the column that is the current expander column.
12325  * This column has the expander arrow drawn next to it.
12326  *
12327  * Return value: (transfer none): The expander column.
12328  **/
12329 GtkTreeViewColumn *
12330 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
12331 {
12332   GList *list;
12333
12334   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12335
12336   for (list = tree_view->priv->columns; list; list = list->next)
12337     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
12338       return (GtkTreeViewColumn *) list->data;
12339   return NULL;
12340 }
12341
12342
12343 /**
12344  * gtk_tree_view_set_column_drag_function:
12345  * @tree_view: A #GtkTreeView.
12346  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
12347  * @user_data: (allow-none): User data to be passed to @func, or %NULL
12348  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
12349  *
12350  * Sets a user function for determining where a column may be dropped when
12351  * dragged.  This function is called on every column pair in turn at the
12352  * beginning of a column drag to determine where a drop can take place.  The
12353  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
12354  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
12355  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
12356  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
12357  * @tree_view reverts to the default behavior of allowing all columns to be
12358  * dropped everywhere.
12359  **/
12360 void
12361 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
12362                                         GtkTreeViewColumnDropFunc  func,
12363                                         gpointer                   user_data,
12364                                         GDestroyNotify             destroy)
12365 {
12366   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12367
12368   if (tree_view->priv->column_drop_func_data_destroy)
12369     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
12370
12371   tree_view->priv->column_drop_func = func;
12372   tree_view->priv->column_drop_func_data = user_data;
12373   tree_view->priv->column_drop_func_data_destroy = destroy;
12374 }
12375
12376 /**
12377  * gtk_tree_view_scroll_to_point:
12378  * @tree_view: a #GtkTreeView
12379  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
12380  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
12381  *
12382  * Scrolls the tree view such that the top-left corner of the visible
12383  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
12384  * in tree coordinates.  The @tree_view must be realized before
12385  * this function is called.  If it isn't, you probably want to be
12386  * using gtk_tree_view_scroll_to_cell().
12387  *
12388  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
12389  **/
12390 void
12391 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
12392                                gint         tree_x,
12393                                gint         tree_y)
12394 {
12395   GtkAdjustment *hadj;
12396   GtkAdjustment *vadj;
12397
12398   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12399   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
12400
12401   hadj = tree_view->priv->hadjustment;
12402   vadj = tree_view->priv->vadjustment;
12403
12404   if (tree_x != -1)
12405     gtk_adjustment_set_value (hadj, tree_x);
12406   if (tree_y != -1)
12407     gtk_adjustment_set_value (vadj, tree_y);
12408 }
12409
12410 /**
12411  * gtk_tree_view_scroll_to_cell:
12412  * @tree_view: A #GtkTreeView.
12413  * @path: (allow-none): The path of the row to move to, or %NULL.
12414  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
12415  * @use_align: whether to use alignment arguments, or %FALSE.
12416  * @row_align: The vertical alignment of the row specified by @path.
12417  * @col_align: The horizontal alignment of the column specified by @column.
12418  *
12419  * Moves the alignments of @tree_view to the position specified by @column and
12420  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
12421  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
12422  * or @path need to be non-%NULL.  @row_align determines where the row is
12423  * placed, and @col_align determines where @column is placed.  Both are expected
12424  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
12425  * right/bottom alignment, 0.5 means center.
12426  *
12427  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
12428  * tree does the minimum amount of work to scroll the cell onto the screen.
12429  * This means that the cell will be scrolled to the edge closest to its current
12430  * position.  If the cell is currently visible on the screen, nothing is done.
12431  *
12432  * This function only works if the model is set, and @path is a valid row on the
12433  * model.  If the model changes before the @tree_view is realized, the centered
12434  * path will be modified to reflect this change.
12435  **/
12436 void
12437 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
12438                               GtkTreePath       *path,
12439                               GtkTreeViewColumn *column,
12440                               gboolean           use_align,
12441                               gfloat             row_align,
12442                               gfloat             col_align)
12443 {
12444   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12445   g_return_if_fail (tree_view->priv->model != NULL);
12446   g_return_if_fail (tree_view->priv->tree != NULL);
12447   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
12448   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
12449   g_return_if_fail (path != NULL || column != NULL);
12450
12451 #if 0
12452   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
12453            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
12454 #endif
12455   row_align = CLAMP (row_align, 0.0, 1.0);
12456   col_align = CLAMP (col_align, 0.0, 1.0);
12457
12458
12459   /* Note: Despite the benefits that come from having one code path for the
12460    * scrolling code, we short-circuit validate_visible_area's immplementation as
12461    * it is much slower than just going to the point.
12462    */
12463   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
12464       !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
12465       _gtk_widget_get_alloc_needed (GTK_WIDGET (tree_view)) ||
12466       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
12467     {
12468       if (tree_view->priv->scroll_to_path)
12469         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
12470
12471       tree_view->priv->scroll_to_path = NULL;
12472       tree_view->priv->scroll_to_column = NULL;
12473
12474       if (path)
12475         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
12476       if (column)
12477         tree_view->priv->scroll_to_column = column;
12478       tree_view->priv->scroll_to_use_align = use_align;
12479       tree_view->priv->scroll_to_row_align = row_align;
12480       tree_view->priv->scroll_to_col_align = col_align;
12481
12482       install_presize_handler (tree_view);
12483     }
12484   else
12485     {
12486       GdkRectangle cell_rect;
12487       GdkRectangle vis_rect;
12488       gint dest_x, dest_y;
12489
12490       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
12491       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
12492
12493       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
12494
12495       dest_x = vis_rect.x;
12496       dest_y = vis_rect.y;
12497
12498       if (column)
12499         {
12500           if (use_align)
12501             {
12502               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
12503             }
12504           else
12505             {
12506               if (cell_rect.x < vis_rect.x)
12507                 dest_x = cell_rect.x;
12508               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
12509                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
12510             }
12511         }
12512
12513       if (path)
12514         {
12515           if (use_align)
12516             {
12517               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
12518               dest_y = MAX (dest_y, 0);
12519             }
12520           else
12521             {
12522               if (cell_rect.y < vis_rect.y)
12523                 dest_y = cell_rect.y;
12524               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
12525                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
12526             }
12527         }
12528
12529       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
12530     }
12531 }
12532
12533 /**
12534  * gtk_tree_view_row_activated:
12535  * @tree_view: A #GtkTreeView
12536  * @path: The #GtkTreePath to be activated.
12537  * @column: The #GtkTreeViewColumn to be activated.
12538  *
12539  * Activates the cell determined by @path and @column.
12540  **/
12541 void
12542 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
12543                              GtkTreePath       *path,
12544                              GtkTreeViewColumn *column)
12545 {
12546   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12547
12548   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
12549 }
12550
12551
12552 static void
12553 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
12554                                           GtkRBNode *node,
12555                                           gpointer   data)
12556 {
12557   GtkTreeView *tree_view = data;
12558
12559   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
12560       node->children)
12561     {
12562       GtkTreePath *path;
12563       GtkTreeIter iter;
12564
12565       path = _gtk_tree_path_new_from_rbtree (tree, node);
12566       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12567
12568       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12569
12570       gtk_tree_path_free (path);
12571     }
12572
12573   if (node->children)
12574     _gtk_rbtree_traverse (node->children,
12575                           node->children->root,
12576                           G_PRE_ORDER,
12577                           gtk_tree_view_expand_all_emission_helper,
12578                           tree_view);
12579 }
12580
12581 /**
12582  * gtk_tree_view_expand_all:
12583  * @tree_view: A #GtkTreeView.
12584  *
12585  * Recursively expands all nodes in the @tree_view.
12586  **/
12587 void
12588 gtk_tree_view_expand_all (GtkTreeView *tree_view)
12589 {
12590   GtkTreePath *path;
12591   GtkRBTree *tree;
12592   GtkRBNode *node;
12593
12594   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12595
12596   if (tree_view->priv->tree == NULL)
12597     return;
12598
12599   path = gtk_tree_path_new_first ();
12600   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12601
12602   while (node)
12603     {
12604       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
12605       node = _gtk_rbtree_next (tree, node);
12606       gtk_tree_path_next (path);
12607   }
12608
12609   gtk_tree_path_free (path);
12610 }
12611
12612 /**
12613  * gtk_tree_view_collapse_all:
12614  * @tree_view: A #GtkTreeView.
12615  *
12616  * Recursively collapses all visible, expanded nodes in @tree_view.
12617  **/
12618 void
12619 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
12620 {
12621   GtkRBTree *tree;
12622   GtkRBNode *node;
12623   GtkTreePath *path;
12624   gint *indices;
12625
12626   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12627
12628   if (tree_view->priv->tree == NULL)
12629     return;
12630
12631   path = gtk_tree_path_new ();
12632   gtk_tree_path_down (path);
12633   indices = gtk_tree_path_get_indices (path);
12634
12635   tree = tree_view->priv->tree;
12636   node = _gtk_rbtree_first (tree);
12637
12638   while (node)
12639     {
12640       if (node->children)
12641         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12642       indices[0]++;
12643       node = _gtk_rbtree_next (tree, node);
12644     }
12645
12646   gtk_tree_path_free (path);
12647 }
12648
12649 /**
12650  * gtk_tree_view_expand_to_path:
12651  * @tree_view: A #GtkTreeView.
12652  * @path: path to a row.
12653  *
12654  * Expands the row at @path. This will also expand all parent rows of
12655  * @path as necessary.
12656  *
12657  * Since: 2.2
12658  **/
12659 void
12660 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
12661                               GtkTreePath *path)
12662 {
12663   gint i, depth;
12664   gint *indices;
12665   GtkTreePath *tmp;
12666
12667   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12668   g_return_if_fail (path != NULL);
12669
12670   depth = gtk_tree_path_get_depth (path);
12671   indices = gtk_tree_path_get_indices (path);
12672
12673   tmp = gtk_tree_path_new ();
12674   g_return_if_fail (tmp != NULL);
12675
12676   for (i = 0; i < depth; i++)
12677     {
12678       gtk_tree_path_append_index (tmp, indices[i]);
12679       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12680     }
12681
12682   gtk_tree_path_free (tmp);
12683 }
12684
12685 /* FIXME the bool return values for expand_row and collapse_row are
12686  * not analagous; they should be TRUE if the row had children and
12687  * was not already in the requested state.
12688  */
12689
12690
12691 static gboolean
12692 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12693                                GtkTreePath *path,
12694                                GtkRBTree   *tree,
12695                                GtkRBNode   *node,
12696                                gboolean     open_all,
12697                                gboolean     animate)
12698 {
12699   GtkTreeIter iter;
12700   GtkTreeIter temp;
12701   gboolean expand;
12702
12703   if (animate)
12704     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12705                   "gtk-enable-animations", &animate,
12706                   NULL);
12707
12708   remove_auto_expand_timeout (tree_view);
12709
12710   if (node->children && !open_all)
12711     return FALSE;
12712
12713   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12714     return FALSE;
12715
12716   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12717   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12718     return FALSE;
12719
12720
12721    if (node->children && open_all)
12722     {
12723       gboolean retval = FALSE;
12724       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12725
12726       gtk_tree_path_append_index (tmp_path, 0);
12727       tree = node->children;
12728       node = _gtk_rbtree_first (tree);
12729       /* try to expand the children */
12730       do
12731         {
12732          gboolean t;
12733          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12734                                             TRUE, animate);
12735          if (t)
12736            retval = TRUE;
12737
12738          gtk_tree_path_next (tmp_path);
12739          node = _gtk_rbtree_next (tree, node);
12740        }
12741       while (node != NULL);
12742
12743       gtk_tree_path_free (tmp_path);
12744
12745       return retval;
12746     }
12747
12748   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12749
12750   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12751     return FALSE;
12752
12753   if (expand)
12754     return FALSE;
12755
12756   node->children = _gtk_rbtree_new ();
12757   node->children->parent_tree = tree;
12758   node->children->parent_node = node;
12759
12760   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12761
12762   gtk_tree_view_build_tree (tree_view,
12763                             node->children,
12764                             &temp,
12765                             gtk_tree_path_get_depth (path) + 1,
12766                             open_all);
12767
12768   _gtk_tree_view_accessible_add (tree_view, node->children, NULL);
12769   _gtk_tree_view_accessible_add_state (tree_view,
12770                                        tree, node,
12771                                        GTK_CELL_RENDERER_EXPANDED);
12772
12773   install_presize_handler (tree_view);
12774
12775   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12776   if (open_all && node->children)
12777     {
12778       _gtk_rbtree_traverse (node->children,
12779                             node->children->root,
12780                             G_PRE_ORDER,
12781                             gtk_tree_view_expand_all_emission_helper,
12782                             tree_view);
12783     }
12784   return TRUE;
12785 }
12786
12787
12788 /**
12789  * gtk_tree_view_expand_row:
12790  * @tree_view: a #GtkTreeView
12791  * @path: path to a row
12792  * @open_all: whether to recursively expand, or just expand immediate children
12793  *
12794  * Opens the row so its children are visible.
12795  *
12796  * Return value: %TRUE if the row existed and had children
12797  **/
12798 gboolean
12799 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12800                           GtkTreePath *path,
12801                           gboolean     open_all)
12802 {
12803   GtkRBTree *tree;
12804   GtkRBNode *node;
12805
12806   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12807   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12808   g_return_val_if_fail (path != NULL, FALSE);
12809
12810   if (_gtk_tree_view_find_node (tree_view,
12811                                 path,
12812                                 &tree,
12813                                 &node))
12814     return FALSE;
12815
12816   if (tree != NULL)
12817     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12818   else
12819     return FALSE;
12820 }
12821
12822 static gboolean
12823 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12824                                  GtkTreePath *path,
12825                                  GtkRBTree   *tree,
12826                                  GtkRBNode   *node,
12827                                  gboolean     animate)
12828 {
12829   GtkTreeIter iter;
12830   GtkTreeIter children;
12831   gboolean collapse;
12832   gint x, y;
12833   GList *list;
12834   GdkWindow *child;
12835   gboolean selection_changed, cursor_changed;
12836
12837   if (animate)
12838     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12839                   "gtk-enable-animations", &animate,
12840                   NULL);
12841
12842   remove_auto_expand_timeout (tree_view);
12843
12844   if (node->children == NULL)
12845     return FALSE;
12846   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12847
12848   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12849
12850   if (collapse)
12851     return FALSE;
12852
12853   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12854    * a chance to prelight the correct node below */
12855
12856   if (tree_view->priv->prelight_tree)
12857     {
12858       GtkRBTree *parent_tree;
12859       GtkRBNode *parent_node;
12860
12861       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12862       parent_node = tree_view->priv->prelight_tree->parent_node;
12863       while (parent_tree)
12864         {
12865           if (parent_tree == tree && parent_node == node)
12866             {
12867               ensure_unprelighted (tree_view);
12868               break;
12869             }
12870           parent_node = parent_tree->parent_node;
12871           parent_tree = parent_tree->parent_tree;
12872         }
12873     }
12874
12875   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12876
12877   for (list = tree_view->priv->columns; list; list = list->next)
12878     {
12879       GtkTreeViewColumn *column = list->data;
12880
12881       if (gtk_tree_view_column_get_visible (column) == FALSE)
12882         continue;
12883       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12884         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12885     }
12886
12887   if (tree_view->priv->destroy_count_func)
12888     {
12889       GtkTreePath *child_path;
12890       gint child_count = 0;
12891       child_path = gtk_tree_path_copy (path);
12892       gtk_tree_path_down (child_path);
12893       if (node->children)
12894         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12895       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12896       gtk_tree_path_free (child_path);
12897     }
12898
12899   if (tree_view->priv->cursor_node)
12900     {
12901       cursor_changed = (node->children == tree_view->priv->cursor_tree)
12902                        || _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree);
12903     }
12904   else
12905     cursor_changed = FALSE;
12906
12907   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12908     {
12909       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12910       if (gtk_tree_path_is_ancestor (path, anchor_path))
12911         {
12912           gtk_tree_row_reference_free (tree_view->priv->anchor);
12913           tree_view->priv->anchor = NULL;
12914         }
12915       gtk_tree_path_free (anchor_path);
12916     }
12917
12918   selection_changed = gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children);
12919
12920   /* Stop a pending double click */
12921   tree_view->priv->last_button_x = -1;
12922   tree_view->priv->last_button_y = -1;
12923
12924   _gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
12925   _gtk_tree_view_accessible_remove_state (tree_view,
12926                                           tree, node,
12927                                           GTK_CELL_RENDERER_EXPANDED);
12928
12929   _gtk_rbtree_remove (node->children);
12930
12931   if (cursor_changed)
12932     gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CURSOR_INVALID);
12933   if (selection_changed)
12934     g_signal_emit_by_name (tree_view->priv->selection, "changed");
12935
12936   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12937     {
12938       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12939     }
12940
12941   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12942
12943   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12944     {
12945       /* now that we've collapsed all rows, we want to try to set the prelight
12946        * again. To do this, we fake a motion event and send it to ourselves. */
12947
12948       child = gdk_window_get_device_position (gdk_window_get_parent (tree_view->priv->bin_window),
12949                                               gdk_device_manager_get_client_pointer (
12950                                                 gdk_display_get_device_manager (
12951                                                   gtk_widget_get_display (GTK_WIDGET (tree_view)))),
12952                                               &x, &y, NULL);
12953       if (child == tree_view->priv->bin_window)
12954         {
12955           GdkEventMotion event;
12956           gint child_x, child_y;
12957
12958           gdk_window_get_position (child, &child_x, &child_y);
12959
12960           event.window = tree_view->priv->bin_window;
12961           event.x = x - child_x;
12962           event.y = y - child_y;
12963
12964           /* despite the fact this isn't a real event, I'm almost positive it will
12965            * never trigger a drag event.  maybe_drag is the only function that uses
12966            * more than just event.x and event.y. */
12967           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
12968         }
12969     }
12970
12971   return TRUE;
12972 }
12973
12974 /**
12975  * gtk_tree_view_collapse_row:
12976  * @tree_view: a #GtkTreeView
12977  * @path: path to a row in the @tree_view
12978  *
12979  * Collapses a row (hides its child rows, if they exist).
12980  *
12981  * Return value: %TRUE if the row was collapsed.
12982  **/
12983 gboolean
12984 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
12985                             GtkTreePath *path)
12986 {
12987   GtkRBTree *tree;
12988   GtkRBNode *node;
12989
12990   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12991   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
12992   g_return_val_if_fail (path != NULL, FALSE);
12993
12994   if (_gtk_tree_view_find_node (tree_view,
12995                                 path,
12996                                 &tree,
12997                                 &node))
12998     return FALSE;
12999
13000   if (tree == NULL || node->children == NULL)
13001     return FALSE;
13002
13003   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
13004 }
13005
13006 static void
13007 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
13008                                         GtkRBTree              *tree,
13009                                         GtkTreePath            *path,
13010                                         GtkTreeViewMappingFunc  func,
13011                                         gpointer                user_data)
13012 {
13013   GtkRBNode *node;
13014
13015   if (tree == NULL || tree->root == NULL)
13016     return;
13017
13018   node = _gtk_rbtree_first (tree);
13019
13020   while (node)
13021     {
13022       if (node->children)
13023         {
13024           (* func) (tree_view, path, user_data);
13025           gtk_tree_path_down (path);
13026           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
13027           gtk_tree_path_up (path);
13028         }
13029       gtk_tree_path_next (path);
13030       node = _gtk_rbtree_next (tree, node);
13031     }
13032 }
13033
13034 /**
13035  * gtk_tree_view_map_expanded_rows:
13036  * @tree_view: A #GtkTreeView
13037  * @func: (scope call): A function to be called
13038  * @data: User data to be passed to the function.
13039  *
13040  * Calls @func on all expanded rows.
13041  **/
13042 void
13043 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
13044                                  GtkTreeViewMappingFunc  func,
13045                                  gpointer                user_data)
13046 {
13047   GtkTreePath *path;
13048
13049   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13050   g_return_if_fail (func != NULL);
13051
13052   path = gtk_tree_path_new_first ();
13053
13054   gtk_tree_view_map_expanded_rows_helper (tree_view,
13055                                           tree_view->priv->tree,
13056                                           path, func, user_data);
13057
13058   gtk_tree_path_free (path);
13059 }
13060
13061 /**
13062  * gtk_tree_view_row_expanded:
13063  * @tree_view: A #GtkTreeView.
13064  * @path: A #GtkTreePath to test expansion state.
13065  *
13066  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
13067  *
13068  * Return value: %TRUE if #path is expanded.
13069  **/
13070 gboolean
13071 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
13072                             GtkTreePath *path)
13073 {
13074   GtkRBTree *tree;
13075   GtkRBNode *node;
13076
13077   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13078   g_return_val_if_fail (path != NULL, FALSE);
13079
13080   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13081
13082   if (node == NULL)
13083     return FALSE;
13084
13085   return (node->children != NULL);
13086 }
13087
13088 /**
13089  * gtk_tree_view_get_reorderable:
13090  * @tree_view: a #GtkTreeView
13091  *
13092  * Retrieves whether the user can reorder the tree via drag-and-drop. See
13093  * gtk_tree_view_set_reorderable().
13094  *
13095  * Return value: %TRUE if the tree can be reordered.
13096  **/
13097 gboolean
13098 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
13099 {
13100   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13101
13102   return tree_view->priv->reorderable;
13103 }
13104
13105 /**
13106  * gtk_tree_view_set_reorderable:
13107  * @tree_view: A #GtkTreeView.
13108  * @reorderable: %TRUE, if the tree can be reordered.
13109  *
13110  * This function is a convenience function to allow you to reorder
13111  * models that support the #GtkTreeDragSourceIface and the
13112  * #GtkTreeDragDestIface.  Both #GtkTreeStore and #GtkListStore support
13113  * these.  If @reorderable is %TRUE, then the user can reorder the
13114  * model by dragging and dropping rows. The developer can listen to
13115  * these changes by connecting to the model's row_inserted and
13116  * row_deleted signals. The reordering is implemented by setting up
13117  * the tree view as a drag source and destination. Therefore, drag and
13118  * drop can not be used in a reorderable view for any other purpose.
13119  *
13120  * This function does not give you any degree of control over the order -- any
13121  * reordering is allowed.  If more control is needed, you should probably
13122  * handle drag and drop manually.
13123  **/
13124 void
13125 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
13126                                gboolean     reorderable)
13127 {
13128   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13129
13130   reorderable = reorderable != FALSE;
13131
13132   if (tree_view->priv->reorderable == reorderable)
13133     return;
13134
13135   if (reorderable)
13136     {
13137       const GtkTargetEntry row_targets[] = {
13138         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
13139       };
13140
13141       gtk_tree_view_enable_model_drag_source (tree_view,
13142                                               GDK_BUTTON1_MASK,
13143                                               row_targets,
13144                                               G_N_ELEMENTS (row_targets),
13145                                               GDK_ACTION_MOVE);
13146       gtk_tree_view_enable_model_drag_dest (tree_view,
13147                                             row_targets,
13148                                             G_N_ELEMENTS (row_targets),
13149                                             GDK_ACTION_MOVE);
13150     }
13151   else
13152     {
13153       gtk_tree_view_unset_rows_drag_source (tree_view);
13154       gtk_tree_view_unset_rows_drag_dest (tree_view);
13155     }
13156
13157   tree_view->priv->reorderable = reorderable;
13158
13159   g_object_notify (G_OBJECT (tree_view), "reorderable");
13160 }
13161
13162 static void
13163 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
13164                                GtkTreePath     *path,
13165                                SetCursorFlags   flags)
13166 {
13167   if (!(flags & CURSOR_INVALID) && tree_view->priv->cursor_node)
13168     {
13169       _gtk_tree_view_accessible_remove_state (tree_view,
13170                                               tree_view->priv->cursor_tree,
13171                                               tree_view->priv->cursor_node,
13172                                               GTK_CELL_RENDERER_FOCUSED);
13173       _gtk_tree_view_queue_draw_node (tree_view,
13174                                       tree_view->priv->cursor_tree,
13175                                       tree_view->priv->cursor_node,
13176                                       NULL);
13177     }
13178
13179   /* One cannot set the cursor on a separator.   Also, if
13180    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
13181    * before finding the tree and node belonging to path.  The
13182    * path maps to a non-existing path and we will silently bail out.
13183    * We unset tree and node to avoid further processing.
13184    */
13185   if (path == NULL ||
13186       row_is_separator (tree_view, NULL, path)
13187       || _gtk_tree_view_find_node (tree_view,
13188                                    path,
13189                                    &tree_view->priv->cursor_tree,
13190                                    &tree_view->priv->cursor_node))
13191     {
13192       tree_view->priv->cursor_tree = NULL;
13193       tree_view->priv->cursor_node = NULL;
13194     }
13195
13196   if (tree_view->priv->cursor_node != NULL)
13197     {
13198       GtkRBTree *new_tree = NULL;
13199       GtkRBNode *new_node = NULL;
13200
13201       if ((flags & CLEAR_AND_SELECT) && !tree_view->priv->modify_selection_pressed)
13202         {
13203           GtkTreeSelectMode mode = 0;
13204
13205           if (tree_view->priv->extend_selection_pressed)
13206             mode |= GTK_TREE_SELECT_MODE_EXTEND;
13207
13208           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
13209                                                     tree_view->priv->cursor_node,
13210                                                     tree_view->priv->cursor_tree,
13211                                                     path,
13212                                                     mode,
13213                                                     FALSE);
13214         }
13215
13216       /* We have to re-find tree and node here again, somebody might have
13217        * cleared the node or the whole tree in the GtkTreeSelection::changed
13218        * callback. If the nodes differ we bail out here.
13219        */
13220       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
13221
13222       if (tree_view->priv->cursor_node != new_node)
13223         return;
13224
13225       if (flags & CLAMP_NODE)
13226         {
13227           gtk_tree_view_clamp_node_visible (tree_view,
13228                                             tree_view->priv->cursor_tree,
13229                                             tree_view->priv->cursor_node);
13230           _gtk_tree_view_queue_draw_node (tree_view,
13231                                           tree_view->priv->cursor_tree,
13232                                           tree_view->priv->cursor_node,
13233                                           NULL);
13234         }
13235
13236       _gtk_tree_view_accessible_add_state (tree_view,
13237                                            tree_view->priv->cursor_tree,
13238                                            tree_view->priv->cursor_node,
13239                                            GTK_CELL_RENDERER_FOCUSED);
13240     }
13241
13242   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
13243 }
13244
13245 /**
13246  * gtk_tree_view_get_cursor:
13247  * @tree_view: A #GtkTreeView
13248  * @path: (out) (transfer full) (allow-none): A pointer to be filled with the current cursor path, or %NULL
13249  * @focus_column: (out) (transfer none) (allow-none): A pointer to be filled with the current focus column, or %NULL
13250  *
13251  * Fills in @path and @focus_column with the current path and focus column.  If
13252  * the cursor isn't currently set, then *@path will be %NULL.  If no column
13253  * currently has focus, then *@focus_column will be %NULL.
13254  *
13255  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
13256  * you are done with it.
13257  **/
13258 void
13259 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
13260                           GtkTreePath       **path,
13261                           GtkTreeViewColumn **focus_column)
13262 {
13263   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13264
13265   if (path)
13266     {
13267       if (tree_view->priv->cursor_node)
13268         *path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
13269                                                 tree_view->priv->cursor_node);
13270       else
13271         *path = NULL;
13272     }
13273
13274   if (focus_column)
13275     {
13276       *focus_column = tree_view->priv->focus_column;
13277     }
13278 }
13279
13280 /**
13281  * gtk_tree_view_set_cursor:
13282  * @tree_view: A #GtkTreeView
13283  * @path: A #GtkTreePath
13284  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13285  * @start_editing: %TRUE if the specified cell should start being edited.
13286  *
13287  * Sets the current keyboard focus to be at @path, and selects it.  This is
13288  * useful when you want to focus the user's attention on a particular row.  If
13289  * @focus_column is not %NULL, then focus is given to the column specified by
13290  * it. Additionally, if @focus_column is specified, and @start_editing is
13291  * %TRUE, then editing should be started in the specified cell.
13292  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
13293  * in order to give keyboard focus to the widget.  Please note that editing
13294  * can only happen when the widget is realized.
13295  *
13296  * If @path is invalid for @model, the current cursor (if any) will be unset
13297  * and the function will return without failing.
13298  **/
13299 void
13300 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
13301                           GtkTreePath       *path,
13302                           GtkTreeViewColumn *focus_column,
13303                           gboolean           start_editing)
13304 {
13305   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
13306                                     NULL, start_editing);
13307 }
13308
13309 /**
13310  * gtk_tree_view_set_cursor_on_cell:
13311  * @tree_view: A #GtkTreeView
13312  * @path: A #GtkTreePath
13313  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13314  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
13315  * @start_editing: %TRUE if the specified cell should start being edited.
13316  *
13317  * Sets the current keyboard focus to be at @path, and selects it.  This is
13318  * useful when you want to focus the user's attention on a particular row.  If
13319  * @focus_column is not %NULL, then focus is given to the column specified by
13320  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
13321  * contains 2 or more editable or activatable cells, then focus is given to
13322  * the cell specified by @focus_cell. Additionally, if @focus_column is
13323  * specified, and @start_editing is %TRUE, then editing should be started in
13324  * the specified cell.  This function is often followed by
13325  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
13326  * widget.  Please note that editing can only happen when the widget is
13327  * realized.
13328  *
13329  * If @path is invalid for @model, the current cursor (if any) will be unset
13330  * and the function will return without failing.
13331  *
13332  * Since: 2.2
13333  **/
13334 void
13335 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
13336                                   GtkTreePath       *path,
13337                                   GtkTreeViewColumn *focus_column,
13338                                   GtkCellRenderer   *focus_cell,
13339                                   gboolean           start_editing)
13340 {
13341   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13342   g_return_if_fail (path != NULL);
13343   g_return_if_fail (focus_column == NULL || GTK_IS_TREE_VIEW_COLUMN (focus_column));
13344
13345   if (!tree_view->priv->model)
13346     return;
13347
13348   if (focus_cell)
13349     {
13350       g_return_if_fail (focus_column);
13351       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
13352     }
13353
13354   /* cancel the current editing, if it exists */
13355   if (tree_view->priv->edited_column &&
13356       gtk_cell_area_get_edit_widget
13357       (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column))))
13358     gtk_tree_view_stop_editing (tree_view, TRUE);
13359
13360   gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
13361
13362   if (focus_column &&
13363       gtk_tree_view_column_get_visible (focus_column))
13364     {
13365       GList *list;
13366       gboolean column_in_tree = FALSE;
13367
13368       for (list = tree_view->priv->columns; list; list = list->next)
13369         if (list->data == focus_column)
13370           {
13371             column_in_tree = TRUE;
13372             break;
13373           }
13374       g_return_if_fail (column_in_tree);
13375       _gtk_tree_view_set_focus_column (tree_view, focus_column);
13376       if (focus_cell)
13377         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
13378       if (start_editing)
13379         gtk_tree_view_start_editing (tree_view, path, TRUE);
13380     }
13381 }
13382
13383 /**
13384  * gtk_tree_view_get_bin_window:
13385  * @tree_view: A #GtkTreeView
13386  *
13387  * Returns the window that @tree_view renders to.
13388  * This is used primarily to compare to <literal>event->window</literal>
13389  * to confirm that the event on @tree_view is on the right window.
13390  *
13391  * Return value: (transfer none): A #GdkWindow, or %NULL when @tree_view
13392  *     hasn't been realized yet
13393  **/
13394 GdkWindow *
13395 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
13396 {
13397   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13398
13399   return tree_view->priv->bin_window;
13400 }
13401
13402 /**
13403  * gtk_tree_view_get_path_at_pos:
13404  * @tree_view: A #GtkTreeView.
13405  * @x: The x position to be identified (relative to bin_window).
13406  * @y: The y position to be identified (relative to bin_window).
13407  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
13408  * @column: (out) (transfer none) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
13409  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
13410  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
13411  *
13412  * Finds the path at the point (@x, @y), relative to bin_window coordinates
13413  * (please see gtk_tree_view_get_bin_window()).
13414  * That is, @x and @y are relative to an events coordinates. @x and @y must
13415  * come from an event on the @tree_view only where <literal>event->window ==
13416  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
13417  * things like popup menus. If @path is non-%NULL, then it will be filled
13418  * with the #GtkTreePath at that point.  This path should be freed with
13419  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
13420  * with the column at that point.  @cell_x and @cell_y return the coordinates
13421  * relative to the cell background (i.e. the @background_area passed to
13422  * gtk_cell_renderer_render()).  This function is only meaningful if
13423  * @tree_view is realized.  Therefore this function will always return %FALSE
13424  * if @tree_view is not realized or does not have a model.
13425  *
13426  * For converting widget coordinates (eg. the ones you get from
13427  * GtkWidget::query-tooltip), please see
13428  * gtk_tree_view_convert_widget_to_bin_window_coords().
13429  *
13430  * Return value: %TRUE if a row exists at that coordinate.
13431  **/
13432 gboolean
13433 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
13434                                gint                x,
13435                                gint                y,
13436                                GtkTreePath       **path,
13437                                GtkTreeViewColumn **column,
13438                                gint               *cell_x,
13439                                gint               *cell_y)
13440 {
13441   GtkRBTree *tree;
13442   GtkRBNode *node;
13443   gint y_offset;
13444
13445   g_return_val_if_fail (tree_view != NULL, FALSE);
13446
13447   if (path)
13448     *path = NULL;
13449   if (column)
13450     *column = NULL;
13451
13452   if (tree_view->priv->bin_window == NULL)
13453     return FALSE;
13454
13455   if (tree_view->priv->tree == NULL)
13456     return FALSE;
13457
13458   if (x > gtk_adjustment_get_upper (tree_view->priv->hadjustment))
13459     return FALSE;
13460
13461   if (x < 0 || y < 0)
13462     return FALSE;
13463
13464   if (column || cell_x)
13465     {
13466       GtkTreeViewColumn *tmp_column;
13467       GtkTreeViewColumn *last_column = NULL;
13468       GList *list;
13469       gint remaining_x = x;
13470       gboolean found = FALSE;
13471       gboolean rtl;
13472       gint width;
13473
13474       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
13475       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13476            list;
13477            list = (rtl ? list->prev : list->next))
13478         {
13479           tmp_column = list->data;
13480
13481           if (gtk_tree_view_column_get_visible (tmp_column) == FALSE)
13482             continue;
13483
13484           last_column = tmp_column;
13485           width = gtk_tree_view_column_get_width (tmp_column);
13486           if (remaining_x <= width)
13487             {
13488               found = TRUE;
13489
13490               if (column)
13491                 *column = tmp_column;
13492
13493               if (cell_x)
13494                 *cell_x = remaining_x;
13495
13496               break;
13497             }
13498           remaining_x -= width;
13499         }
13500
13501       /* If found is FALSE and there is a last_column, then it the remainder
13502        * space is in that area
13503        */
13504       if (!found)
13505         {
13506           if (last_column)
13507             {
13508               if (column)
13509                 *column = last_column;
13510
13511               if (cell_x)
13512                 *cell_x = gtk_tree_view_column_get_width (last_column) + remaining_x;
13513             }
13514           else
13515             {
13516               return FALSE;
13517             }
13518         }
13519     }
13520
13521   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
13522                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
13523                                       &tree, &node);
13524
13525   if (tree == NULL)
13526     return FALSE;
13527
13528   if (cell_y)
13529     *cell_y = y_offset;
13530
13531   if (path)
13532     *path = _gtk_tree_path_new_from_rbtree (tree, node);
13533
13534   return TRUE;
13535 }
13536
13537
13538 static inline gint
13539 gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
13540                                     GtkRBNode   *node,
13541                                     gint         vertical_separator)
13542 {
13543   int expander_size = gtk_tree_view_get_expander_size (tree_view);
13544   int height;
13545
13546   /* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
13547    * i.e. just the cells, no spacing.
13548    *
13549    * The cell area height is at least expander_size - vertical_separator.
13550    * For regular nodes, the height is then at least expander_size. We should
13551    * be able to enforce the expander_size minimum here, because this
13552    * function will not be called for irregular (e.g. separator) rows.
13553    */
13554   height = gtk_tree_view_get_row_height (tree_view, node);
13555   if (height < expander_size)
13556     height = expander_size;
13557
13558   return height - vertical_separator;
13559 }
13560
13561 static inline gint
13562 gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
13563                                       GtkRBTree   *tree,
13564                                       GtkRBNode   *node,
13565                                       gint         vertical_separator)
13566 {
13567   int offset;
13568
13569   offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13570   offset += vertical_separator / 2;
13571
13572   return offset;
13573 }
13574
13575 /**
13576  * gtk_tree_view_get_cell_area:
13577  * @tree_view: a #GtkTreeView
13578  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13579  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
13580  * @rect: (out): rectangle to fill with cell rect
13581  *
13582  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13583  * row specified by @path and the column specified by @column.  If @path is
13584  * %NULL, or points to a path not currently displayed, the @y and @height fields
13585  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13586  * fields will be filled with 0.  The sum of all cell rects does not cover the
13587  * entire tree; there are extra pixels in between rows, for example. The
13588  * returned rectangle is equivalent to the @cell_area passed to
13589  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
13590  * realized.
13591  **/
13592 void
13593 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
13594                              GtkTreePath        *path,
13595                              GtkTreeViewColumn  *column,
13596                              GdkRectangle       *rect)
13597 {
13598   GtkRBTree *tree = NULL;
13599   GtkRBNode *node = NULL;
13600   gint vertical_separator;
13601   gint horizontal_separator;
13602
13603   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13604   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13605   g_return_if_fail (rect != NULL);
13606   g_return_if_fail (!column || gtk_tree_view_column_get_tree_view (column) == (GtkWidget *) tree_view);
13607   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
13608
13609   gtk_widget_style_get (GTK_WIDGET (tree_view),
13610                         "vertical-separator", &vertical_separator,
13611                         "horizontal-separator", &horizontal_separator,
13612                         NULL);
13613
13614   rect->x = 0;
13615   rect->y = 0;
13616   rect->width = 0;
13617   rect->height = 0;
13618
13619   if (column)
13620     {
13621       rect->x = gtk_tree_view_column_get_x_offset (column) + horizontal_separator/2;
13622       rect->width = gtk_tree_view_column_get_width (column) - horizontal_separator;
13623     }
13624
13625   if (path)
13626     {
13627       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13628
13629       /* Get vertical coords */
13630       if ((!ret && tree == NULL) || ret)
13631         return;
13632
13633       if (row_is_separator (tree_view, NULL, path))
13634         {
13635           /* There isn't really a "cell area" for separator, so we
13636            * return the y, height values for background area instead.
13637            */
13638           rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13639           rect->height = gtk_tree_view_get_row_height (tree_view, node);
13640         }
13641       else
13642         {
13643           rect->y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
13644                                                           vertical_separator);
13645           rect->height = gtk_tree_view_get_cell_area_height (tree_view, node,
13646                                                              vertical_separator);
13647         }
13648
13649       if (column &&
13650           gtk_tree_view_is_expander_column (tree_view, column))
13651         {
13652           gint depth = gtk_tree_path_get_depth (path);
13653           gboolean rtl;
13654
13655           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13656
13657           if (!rtl)
13658             rect->x += (depth - 1) * tree_view->priv->level_indentation;
13659           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
13660
13661           if (gtk_tree_view_draw_expanders (tree_view))
13662             {
13663               int expander_size = gtk_tree_view_get_expander_size (tree_view);
13664               if (!rtl)
13665                 rect->x += depth * expander_size;
13666               rect->width -= depth * expander_size;
13667             }
13668
13669           rect->width = MAX (rect->width, 0);
13670         }
13671     }
13672 }
13673
13674 static inline gint
13675 gtk_tree_view_get_row_height (GtkTreeView *tree_view,
13676                               GtkRBNode   *node)
13677 {
13678   int expander_size = gtk_tree_view_get_expander_size (tree_view);
13679   int height;
13680
13681   /* The "background" areas of all rows/cells add up to cover the entire tree.
13682    * The background includes all inter-row and inter-cell spacing.
13683    *
13684    * If the row pointed at by node does not have a height set, we default
13685    * to expander_size, which is the minimum height for regular nodes.
13686    * Non-regular nodes (e.g. separators) can have a height set smaller
13687    * than expander_size and should not be overruled here.
13688    */
13689   height = GTK_RBNODE_GET_HEIGHT (node);
13690   if (height <= 0)
13691     height = expander_size;
13692
13693   return height;
13694 }
13695
13696 static inline gint
13697 gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
13698                                 GtkRBTree   *tree,
13699                                 GtkRBNode   *node)
13700 {
13701   int offset;
13702
13703   offset = _gtk_rbtree_node_find_offset (tree, node);
13704
13705   return RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, offset);
13706 }
13707
13708 /**
13709  * gtk_tree_view_get_background_area:
13710  * @tree_view: a #GtkTreeView
13711  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13712  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
13713  * @rect: (out): rectangle to fill with cell background rect
13714  *
13715  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13716  * row specified by @path and the column specified by @column.  If @path is
13717  * %NULL, or points to a node not found in the tree, the @y and @height fields of
13718  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13719  * fields will be filled with 0.  The returned rectangle is equivalent to the
13720  * @background_area passed to gtk_cell_renderer_render().  These background
13721  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
13722  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
13723  * itself, excluding surrounding borders and the tree expander area.
13724  *
13725  **/
13726 void
13727 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
13728                                    GtkTreePath        *path,
13729                                    GtkTreeViewColumn  *column,
13730                                    GdkRectangle       *rect)
13731 {
13732   GtkRBTree *tree = NULL;
13733   GtkRBNode *node = NULL;
13734
13735   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13736   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13737   g_return_if_fail (rect != NULL);
13738
13739   rect->x = 0;
13740   rect->y = 0;
13741   rect->width = 0;
13742   rect->height = 0;
13743
13744   if (path)
13745     {
13746       /* Get vertical coords */
13747
13748       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
13749           tree == NULL)
13750         return;
13751
13752       rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13753       rect->height = gtk_tree_view_get_row_height (tree_view, node);
13754     }
13755
13756   if (column)
13757     {
13758       gint x2 = 0;
13759
13760       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
13761       rect->width = x2 - rect->x;
13762     }
13763 }
13764
13765 /**
13766  * gtk_tree_view_get_visible_rect:
13767  * @tree_view: a #GtkTreeView
13768  * @visible_rect: (out): rectangle to fill
13769  *
13770  * Fills @visible_rect with the currently-visible region of the
13771  * buffer, in tree coordinates. Convert to bin_window coordinates with
13772  * gtk_tree_view_convert_tree_to_bin_window_coords().
13773  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
13774  * scrollable area of the tree.
13775  **/
13776 void
13777 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
13778                                 GdkRectangle *visible_rect)
13779 {
13780   GtkAllocation allocation;
13781   GtkWidget *widget;
13782
13783   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13784
13785   widget = GTK_WIDGET (tree_view);
13786
13787   if (visible_rect)
13788     {
13789       gtk_widget_get_allocation (widget, &allocation);
13790       visible_rect->x = gtk_adjustment_get_value (tree_view->priv->hadjustment);
13791       visible_rect->y = gtk_adjustment_get_value (tree_view->priv->vadjustment);
13792       visible_rect->width = allocation.width;
13793       visible_rect->height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
13794     }
13795 }
13796
13797 /**
13798  * gtk_tree_view_convert_widget_to_tree_coords:
13799  * @tree_view: a #GtkTreeView
13800  * @wx: X coordinate relative to the widget
13801  * @wy: Y coordinate relative to the widget
13802  * @tx: (out): return location for tree X coordinate
13803  * @ty: (out): return location for tree Y coordinate
13804  *
13805  * Converts widget coordinates to coordinates for the
13806  * tree (the full scrollable area of the tree).
13807  *
13808  * Since: 2.12
13809  **/
13810 void
13811 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13812                                              gint         wx,
13813                                              gint         wy,
13814                                              gint        *tx,
13815                                              gint        *ty)
13816 {
13817   gint x, y;
13818
13819   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13820
13821   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13822                                                      wx, wy,
13823                                                      &x, &y);
13824   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13825                                                    x, y,
13826                                                    tx, ty);
13827 }
13828
13829 /**
13830  * gtk_tree_view_convert_tree_to_widget_coords:
13831  * @tree_view: a #GtkTreeView
13832  * @tx: X coordinate relative to the tree
13833  * @ty: Y coordinate relative to the tree
13834  * @wx: (out): return location for widget X coordinate
13835  * @wy: (out): return location for widget Y coordinate
13836  *
13837  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13838  * to widget coordinates.
13839  *
13840  * Since: 2.12
13841  **/
13842 void
13843 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13844                                              gint         tx,
13845                                              gint         ty,
13846                                              gint        *wx,
13847                                              gint        *wy)
13848 {
13849   gint x, y;
13850
13851   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13852
13853   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13854                                                    tx, ty,
13855                                                    &x, &y);
13856   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13857                                                      x, y,
13858                                                      wx, wy);
13859 }
13860
13861 /**
13862  * gtk_tree_view_convert_widget_to_bin_window_coords:
13863  * @tree_view: a #GtkTreeView
13864  * @wx: X coordinate relative to the widget
13865  * @wy: Y coordinate relative to the widget
13866  * @bx: (out): return location for bin_window X coordinate
13867  * @by: (out): return location for bin_window Y coordinate
13868  *
13869  * Converts widget coordinates to coordinates for the bin_window
13870  * (see gtk_tree_view_get_bin_window()).
13871  *
13872  * Since: 2.12
13873  **/
13874 void
13875 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13876                                                    gint         wx,
13877                                                    gint         wy,
13878                                                    gint        *bx,
13879                                                    gint        *by)
13880 {
13881   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13882
13883   if (bx)
13884     *bx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
13885   if (by)
13886     *by = wy - gtk_tree_view_get_effective_header_height (tree_view);
13887 }
13888
13889 /**
13890  * gtk_tree_view_convert_bin_window_to_widget_coords:
13891  * @tree_view: a #GtkTreeView
13892  * @bx: bin_window X coordinate
13893  * @by: bin_window Y coordinate
13894  * @wx: (out): return location for widget X coordinate
13895  * @wy: (out): return location for widget Y coordinate
13896  *
13897  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13898  * to widget relative coordinates.
13899  *
13900  * Since: 2.12
13901  **/
13902 void
13903 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13904                                                    gint         bx,
13905                                                    gint         by,
13906                                                    gint        *wx,
13907                                                    gint        *wy)
13908 {
13909   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13910
13911   if (wx)
13912     *wx = bx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
13913   if (wy)
13914     *wy = by + gtk_tree_view_get_effective_header_height (tree_view);
13915 }
13916
13917 /**
13918  * gtk_tree_view_convert_tree_to_bin_window_coords:
13919  * @tree_view: a #GtkTreeView
13920  * @tx: tree X coordinate
13921  * @ty: tree Y coordinate
13922  * @bx: (out): return location for X coordinate relative to bin_window
13923  * @by: (out): return location for Y coordinate relative to bin_window
13924  *
13925  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13926  * to bin_window coordinates.
13927  *
13928  * Since: 2.12
13929  **/
13930 void
13931 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13932                                                  gint         tx,
13933                                                  gint         ty,
13934                                                  gint        *bx,
13935                                                  gint        *by)
13936 {
13937   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13938
13939   if (bx)
13940     *bx = tx;
13941   if (by)
13942     *by = ty - tree_view->priv->dy;
13943 }
13944
13945 /**
13946  * gtk_tree_view_convert_bin_window_to_tree_coords:
13947  * @tree_view: a #GtkTreeView
13948  * @bx: X coordinate relative to bin_window
13949  * @by: Y coordinate relative to bin_window
13950  * @tx: (out): return location for tree X coordinate
13951  * @ty: (out): return location for tree Y coordinate
13952  *
13953  * Converts bin_window coordinates to coordinates for the
13954  * tree (the full scrollable area of the tree).
13955  *
13956  * Since: 2.12
13957  **/
13958 void
13959 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
13960                                                  gint         bx,
13961                                                  gint         by,
13962                                                  gint        *tx,
13963                                                  gint        *ty)
13964 {
13965   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13966
13967   if (tx)
13968     *tx = bx;
13969   if (ty)
13970     *ty = by + tree_view->priv->dy;
13971 }
13972
13973
13974
13975 /**
13976  * gtk_tree_view_get_visible_range:
13977  * @tree_view: A #GtkTreeView
13978  * @start_path: (out) (allow-none): Return location for start of region,
13979  *              or %NULL.
13980  * @end_path: (out) (allow-none): Return location for end of region, or %NULL.
13981  *
13982  * Sets @start_path and @end_path to be the first and last visible path.
13983  * Note that there may be invisible paths in between.
13984  *
13985  * The paths should be freed with gtk_tree_path_free() after use.
13986  *
13987  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
13988  *
13989  * Since: 2.8
13990  **/
13991 gboolean
13992 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
13993                                  GtkTreePath **start_path,
13994                                  GtkTreePath **end_path)
13995 {
13996   GtkRBTree *tree;
13997   GtkRBNode *node;
13998   gboolean retval;
13999
14000   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14001
14002   if (!tree_view->priv->tree)
14003     return FALSE;
14004
14005   retval = TRUE;
14006
14007   if (start_path)
14008     {
14009       _gtk_rbtree_find_offset (tree_view->priv->tree,
14010                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
14011                                &tree, &node);
14012       if (node)
14013         *start_path = _gtk_tree_path_new_from_rbtree (tree, node);
14014       else
14015         retval = FALSE;
14016     }
14017
14018   if (end_path)
14019     {
14020       gint y;
14021
14022       if (tree_view->priv->height < gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
14023         y = tree_view->priv->height - 1;
14024       else
14025         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1;
14026
14027       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
14028       if (node)
14029         *end_path = _gtk_tree_path_new_from_rbtree (tree, node);
14030       else
14031         retval = FALSE;
14032     }
14033
14034   return retval;
14035 }
14036
14037 /**
14038  * gtk_tree_view_is_blank_at_pos:
14039  * @tree_view: A #GtkTreeView
14040  * @x: The x position to be identified (relative to bin_window)
14041  * @y: The y position to be identified (relative to bin_window)
14042  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
14043  * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
14044  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
14045  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
14046  *
14047  * Determine whether the point (@x, @y) in @tree_view is blank, that is no
14048  * cell content nor an expander arrow is drawn at the location. If so, the
14049  * location can be considered as the background. You might wish to take
14050  * special action on clicks on the background, such as clearing a current
14051  * selection, having a custom context menu or starting rubber banding.
14052  *
14053  * The @x and @y coordinate that are provided must be relative to bin_window
14054  * coordinates.  That is, @x and @y must come from an event on @tree_view
14055  * where <literal>event->window == gtk_tree_view_get_bin_window (<!-- -->)</literal>.
14056  *
14057  * For converting widget coordinates (eg. the ones you get from
14058  * GtkWidget::query-tooltip), please see
14059  * gtk_tree_view_convert_widget_to_bin_window_coords().
14060  *
14061  * The @path, @column, @cell_x and @cell_y arguments will be filled in
14062  * likewise as for gtk_tree_view_get_path_at_pos().  Please see
14063  * gtk_tree_view_get_path_at_pos() for more information.
14064  *
14065  * Return value: %TRUE if the area at the given coordinates is blank,
14066  * %FALSE otherwise.
14067  *
14068  * Since: 3.0
14069  */
14070 gboolean
14071 gtk_tree_view_is_blank_at_pos (GtkTreeView       *tree_view,
14072                                gint                x,
14073                                gint                y,
14074                                GtkTreePath       **path,
14075                                GtkTreeViewColumn **column,
14076                                gint               *cell_x,
14077                                gint               *cell_y)
14078 {
14079   GtkRBTree *tree;
14080   GtkRBNode *node;
14081   GtkTreeIter iter;
14082   GtkTreePath *real_path;
14083   GtkTreeViewColumn *real_column;
14084   GdkRectangle cell_area, background_area;
14085
14086   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14087
14088   if (!gtk_tree_view_get_path_at_pos (tree_view, x, y,
14089                                       &real_path, &real_column,
14090                                       cell_x, cell_y))
14091     /* If there's no path here, it is blank */
14092     return TRUE;
14093
14094   if (path)
14095     *path = real_path;
14096
14097   if (column)
14098     *column = real_column;
14099
14100   gtk_tree_model_get_iter (tree_view->priv->model, &iter, real_path);
14101   _gtk_tree_view_find_node (tree_view, real_path, &tree, &node);
14102
14103   /* Check if there's an expander arrow at (x, y) */
14104   if (real_column == tree_view->priv->expander_column
14105       && gtk_tree_view_draw_expanders (tree_view))
14106     {
14107       gboolean over_arrow;
14108
14109       over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
14110
14111       if (over_arrow)
14112         {
14113           if (!path)
14114             gtk_tree_path_free (real_path);
14115           return FALSE;
14116         }
14117     }
14118
14119   /* Otherwise, have the column see if there's a cell at (x, y) */
14120   gtk_tree_view_column_cell_set_cell_data (real_column,
14121                                            tree_view->priv->model,
14122                                            &iter,
14123                                            GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14124                                            node->children ? TRUE : FALSE);
14125
14126   gtk_tree_view_get_background_area (tree_view, real_path, real_column,
14127                                      &background_area);
14128   gtk_tree_view_get_cell_area (tree_view, real_path, real_column,
14129                                &cell_area);
14130
14131   if (!path)
14132     gtk_tree_path_free (real_path);
14133
14134   return _gtk_tree_view_column_is_blank_at_pos (real_column,
14135                                                 &cell_area,
14136                                                 &background_area,
14137                                                 x, y);
14138 }
14139
14140 static void
14141 unset_reorderable (GtkTreeView *tree_view)
14142 {
14143   if (tree_view->priv->reorderable)
14144     {
14145       tree_view->priv->reorderable = FALSE;
14146       g_object_notify (G_OBJECT (tree_view), "reorderable");
14147     }
14148 }
14149
14150 /**
14151  * gtk_tree_view_enable_model_drag_source:
14152  * @tree_view: a #GtkTreeView
14153  * @start_button_mask: Mask of allowed buttons to start drag
14154  * @targets: (array length=n_targets): the table of targets that the drag will support
14155  * @n_targets: the number of items in @targets
14156  * @actions: the bitmask of possible actions for a drag from this
14157  *    widget
14158  *
14159  * Turns @tree_view into a drag source for automatic DND. Calling this
14160  * method sets #GtkTreeView:reorderable to %FALSE.
14161  **/
14162 void
14163 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
14164                                         GdkModifierType           start_button_mask,
14165                                         const GtkTargetEntry     *targets,
14166                                         gint                      n_targets,
14167                                         GdkDragAction             actions)
14168 {
14169   TreeViewDragInfo *di;
14170
14171   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14172
14173   gtk_drag_source_set (GTK_WIDGET (tree_view),
14174                        0,
14175                        targets,
14176                        n_targets,
14177                        actions);
14178
14179   di = ensure_info (tree_view);
14180
14181   di->start_button_mask = start_button_mask;
14182   di->source_actions = actions;
14183   di->source_set = TRUE;
14184
14185   unset_reorderable (tree_view);
14186 }
14187
14188 /**
14189  * gtk_tree_view_enable_model_drag_dest:
14190  * @tree_view: a #GtkTreeView
14191  * @targets: (array length=n_targets): the table of targets that
14192  *           the drag will support
14193  * @n_targets: the number of items in @targets
14194  * @actions: the bitmask of possible actions for a drag from this
14195  *    widget
14196  *
14197  * Turns @tree_view into a drop destination for automatic DND. Calling
14198  * this method sets #GtkTreeView:reorderable to %FALSE.
14199  **/
14200 void
14201 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
14202                                       const GtkTargetEntry     *targets,
14203                                       gint                      n_targets,
14204                                       GdkDragAction             actions)
14205 {
14206   TreeViewDragInfo *di;
14207
14208   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14209
14210   gtk_drag_dest_set (GTK_WIDGET (tree_view),
14211                      0,
14212                      targets,
14213                      n_targets,
14214                      actions);
14215
14216   di = ensure_info (tree_view);
14217   di->dest_set = TRUE;
14218
14219   unset_reorderable (tree_view);
14220 }
14221
14222 /**
14223  * gtk_tree_view_unset_rows_drag_source:
14224  * @tree_view: a #GtkTreeView
14225  *
14226  * Undoes the effect of
14227  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
14228  * #GtkTreeView:reorderable to %FALSE.
14229  **/
14230 void
14231 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
14232 {
14233   TreeViewDragInfo *di;
14234
14235   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14236
14237   di = get_info (tree_view);
14238
14239   if (di)
14240     {
14241       if (di->source_set)
14242         {
14243           gtk_drag_source_unset (GTK_WIDGET (tree_view));
14244           di->source_set = FALSE;
14245         }
14246
14247       if (!di->dest_set && !di->source_set)
14248         remove_info (tree_view);
14249     }
14250
14251   unset_reorderable (tree_view);
14252 }
14253
14254 /**
14255  * gtk_tree_view_unset_rows_drag_dest:
14256  * @tree_view: a #GtkTreeView
14257  *
14258  * Undoes the effect of
14259  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
14260  * #GtkTreeView:reorderable to %FALSE.
14261  **/
14262 void
14263 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
14264 {
14265   TreeViewDragInfo *di;
14266
14267   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14268
14269   di = get_info (tree_view);
14270
14271   if (di)
14272     {
14273       if (di->dest_set)
14274         {
14275           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
14276           di->dest_set = FALSE;
14277         }
14278
14279       if (!di->dest_set && !di->source_set)
14280         remove_info (tree_view);
14281     }
14282
14283   unset_reorderable (tree_view);
14284 }
14285
14286 /**
14287  * gtk_tree_view_set_drag_dest_row:
14288  * @tree_view: a #GtkTreeView
14289  * @path: (allow-none): The path of the row to highlight, or %NULL
14290  * @pos: Specifies whether to drop before, after or into the row
14291  *
14292  * Sets the row that is highlighted for feedback.
14293  * If @path is %NULL, an existing highlight is removed.
14294  */
14295 void
14296 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
14297                                  GtkTreePath            *path,
14298                                  GtkTreeViewDropPosition pos)
14299 {
14300   GtkTreePath *current_dest;
14301
14302   /* Note; this function is exported to allow a custom DND
14303    * implementation, so it can't touch TreeViewDragInfo
14304    */
14305
14306   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14307
14308   current_dest = NULL;
14309
14310   if (tree_view->priv->drag_dest_row)
14311     {
14312       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14313       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
14314     }
14315
14316   /* special case a drop on an empty model */
14317   tree_view->priv->empty_view_drop = 0;
14318
14319   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
14320       && gtk_tree_path_get_depth (path) == 1
14321       && gtk_tree_path_get_indices (path)[0] == 0)
14322     {
14323       gint n_children;
14324
14325       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
14326                                                    NULL);
14327
14328       if (!n_children)
14329         tree_view->priv->empty_view_drop = 1;
14330     }
14331
14332   tree_view->priv->drag_dest_pos = pos;
14333
14334   if (path)
14335     {
14336       tree_view->priv->drag_dest_row =
14337         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
14338       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
14339     }
14340   else
14341     tree_view->priv->drag_dest_row = NULL;
14342
14343   if (current_dest)
14344     {
14345       GtkRBTree *tree, *new_tree;
14346       GtkRBNode *node, *new_node;
14347
14348       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
14349       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
14350
14351       if (tree && node)
14352         {
14353           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
14354           if (new_tree && new_node)
14355             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14356
14357           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
14358           if (new_tree && new_node)
14359             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14360         }
14361       gtk_tree_path_free (current_dest);
14362     }
14363 }
14364
14365 /**
14366  * gtk_tree_view_get_drag_dest_row:
14367  * @tree_view: a #GtkTreeView
14368  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14369  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14370  *
14371  * Gets information about the row that is highlighted for feedback.
14372  **/
14373 void
14374 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
14375                                  GtkTreePath             **path,
14376                                  GtkTreeViewDropPosition  *pos)
14377 {
14378   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14379
14380   if (path)
14381     {
14382       if (tree_view->priv->drag_dest_row)
14383         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14384       else
14385         {
14386           if (tree_view->priv->empty_view_drop)
14387             *path = gtk_tree_path_new_from_indices (0, -1);
14388           else
14389             *path = NULL;
14390         }
14391     }
14392
14393   if (pos)
14394     *pos = tree_view->priv->drag_dest_pos;
14395 }
14396
14397 /**
14398  * gtk_tree_view_get_dest_row_at_pos:
14399  * @tree_view: a #GtkTreeView
14400  * @drag_x: the position to determine the destination row for
14401  * @drag_y: the position to determine the destination row for
14402  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14403  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14404  *
14405  * Determines the destination row for a given position.  @drag_x and
14406  * @drag_y are expected to be in widget coordinates.  This function is only
14407  * meaningful if @tree_view is realized.  Therefore this function will always
14408  * return %FALSE if @tree_view is not realized or does not have a model.
14409  *
14410  * Return value: whether there is a row at the given position, %TRUE if this
14411  * is indeed the case.
14412  **/
14413 gboolean
14414 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
14415                                    gint                     drag_x,
14416                                    gint                     drag_y,
14417                                    GtkTreePath            **path,
14418                                    GtkTreeViewDropPosition *pos)
14419 {
14420   gint cell_y;
14421   gint bin_x, bin_y;
14422   gdouble offset_into_row;
14423   gdouble third;
14424   GdkRectangle cell;
14425   GtkTreeViewColumn *column = NULL;
14426   GtkTreePath *tmp_path = NULL;
14427
14428   /* Note; this function is exported to allow a custom DND
14429    * implementation, so it can't touch TreeViewDragInfo
14430    */
14431
14432   g_return_val_if_fail (tree_view != NULL, FALSE);
14433   g_return_val_if_fail (drag_x >= 0, FALSE);
14434   g_return_val_if_fail (drag_y >= 0, FALSE);
14435
14436   if (path)
14437     *path = NULL;
14438
14439   if (tree_view->priv->bin_window == NULL)
14440     return FALSE;
14441
14442   if (tree_view->priv->tree == NULL)
14443     return FALSE;
14444
14445   /* If in the top third of a row, we drop before that row; if
14446    * in the bottom third, drop after that row; if in the middle,
14447    * and the row has children, drop into the row.
14448    */
14449   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
14450                                                      &bin_x, &bin_y);
14451
14452   if (!gtk_tree_view_get_path_at_pos (tree_view,
14453                                       bin_x,
14454                                       bin_y,
14455                                       &tmp_path,
14456                                       &column,
14457                                       NULL,
14458                                       &cell_y))
14459     return FALSE;
14460
14461   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
14462                                      &cell);
14463
14464   offset_into_row = cell_y;
14465
14466   if (path)
14467     *path = tmp_path;
14468   else
14469     gtk_tree_path_free (tmp_path);
14470
14471   tmp_path = NULL;
14472
14473   third = cell.height / 3.0;
14474
14475   if (pos)
14476     {
14477       if (offset_into_row < third)
14478         {
14479           *pos = GTK_TREE_VIEW_DROP_BEFORE;
14480         }
14481       else if (offset_into_row < (cell.height / 2.0))
14482         {
14483           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
14484         }
14485       else if (offset_into_row < third * 2.0)
14486         {
14487           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
14488         }
14489       else
14490         {
14491           *pos = GTK_TREE_VIEW_DROP_AFTER;
14492         }
14493     }
14494
14495   return TRUE;
14496 }
14497
14498
14499
14500 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
14501 /**
14502  * gtk_tree_view_create_row_drag_icon:
14503  * @tree_view: a #GtkTreeView
14504  * @path: a #GtkTreePath in @tree_view
14505  *
14506  * Creates a #cairo_surface_t representation of the row at @path.
14507  * This image is used for a drag icon.
14508  *
14509  * Return value: (transfer full): a newly-allocated surface of the drag icon.
14510  **/
14511 cairo_surface_t *
14512 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
14513                                     GtkTreePath  *path)
14514 {
14515   GtkTreeIter   iter;
14516   GtkRBTree    *tree;
14517   GtkRBNode    *node;
14518   GtkStyleContext *context;
14519   gint cell_offset;
14520   GList *list;
14521   GdkRectangle background_area;
14522   GtkWidget *widget;
14523   gint depth;
14524   /* start drawing inside the black outline */
14525   gint x = 1, y = 1;
14526   cairo_surface_t *surface;
14527   gint bin_window_width;
14528   gboolean is_separator = FALSE;
14529   gboolean rtl, allow_rules;
14530   cairo_t *cr;
14531
14532   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14533   g_return_val_if_fail (path != NULL, NULL);
14534
14535   widget = GTK_WIDGET (tree_view);
14536
14537   if (!gtk_widget_get_realized (widget))
14538     return NULL;
14539
14540   depth = gtk_tree_path_get_depth (path);
14541
14542   _gtk_tree_view_find_node (tree_view,
14543                             path,
14544                             &tree,
14545                             &node);
14546
14547   if (tree == NULL)
14548     return NULL;
14549
14550   if (!gtk_tree_model_get_iter (tree_view->priv->model,
14551                                 &iter,
14552                                 path))
14553     return NULL;
14554
14555   context = gtk_widget_get_style_context (widget);
14556
14557   gtk_style_context_save (context);
14558
14559   gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
14560   gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0);
14561
14562   gtk_widget_style_get (widget,
14563                         "allow-rules", &allow_rules,
14564                         NULL);
14565
14566   if (allow_rules && tree_view->priv->has_rules)
14567     {
14568       GtkRegionFlags row_flags;
14569
14570       if ((_gtk_rbtree_node_get_index (tree, node) % 2))
14571         row_flags = GTK_REGION_ODD;
14572       else
14573         row_flags = GTK_REGION_EVEN;
14574
14575       gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
14576     }
14577
14578   is_separator = row_is_separator (tree_view, &iter, NULL);
14579
14580   cell_offset = x;
14581
14582   background_area.y = y;
14583   background_area.height = gtk_tree_view_get_row_height (tree_view, node);
14584
14585   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
14586
14587   surface = gdk_window_create_similar_surface (tree_view->priv->bin_window,
14588                                                CAIRO_CONTENT_COLOR,
14589                                                bin_window_width + 2,
14590                                                background_area.height + 2);
14591
14592   cr = cairo_create (surface);
14593
14594   gtk_render_background (context, cr, 0, 0,
14595                          bin_window_width + 2,
14596                          background_area.height + 2);
14597
14598   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
14599
14600   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
14601       list;
14602       list = (rtl ? list->prev : list->next))
14603     {
14604       GtkTreeViewColumn *column = list->data;
14605       GdkRectangle cell_area;
14606       gint vertical_separator;
14607
14608       if (!gtk_tree_view_column_get_visible (column))
14609         continue;
14610
14611       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
14612                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14613                                                node->children?TRUE:FALSE);
14614
14615       background_area.x = cell_offset;
14616       background_area.width = gtk_tree_view_column_get_width (column);
14617
14618       gtk_widget_style_get (widget,
14619                             "vertical-separator", &vertical_separator,
14620                             NULL);
14621
14622       cell_area = background_area;
14623
14624       cell_area.y += vertical_separator / 2;
14625       cell_area.height -= vertical_separator;
14626
14627       if (gtk_tree_view_is_expander_column (tree_view, column))
14628         {
14629           if (!rtl)
14630             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
14631           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
14632
14633           if (gtk_tree_view_draw_expanders (tree_view))
14634             {
14635               int expander_size = gtk_tree_view_get_expander_size (tree_view);
14636               if (!rtl)
14637                 cell_area.x += depth * expander_size;
14638               cell_area.width -= depth * expander_size;
14639             }
14640         }
14641
14642       if (gtk_tree_view_column_cell_is_visible (column))
14643         {
14644           if (is_separator)
14645             {
14646               gtk_style_context_save (context);
14647               gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
14648
14649               gtk_render_line (context, cr,
14650                                cell_area.x,
14651                                cell_area.y + cell_area.height / 2,
14652                                cell_area.x + cell_area.width,
14653                                cell_area.y + cell_area.height / 2);
14654
14655               gtk_style_context_restore (context);
14656             }
14657           else
14658             {
14659               _gtk_tree_view_column_cell_render (column,
14660                                                  cr,
14661                                                  &background_area,
14662                                                  &cell_area,
14663                                                  0, FALSE);
14664             }
14665         }
14666       cell_offset += gtk_tree_view_column_get_width (column);
14667     }
14668
14669   cairo_set_source_rgb (cr, 0, 0, 0);
14670   cairo_rectangle (cr,
14671                    0.5, 0.5,
14672                    bin_window_width + 1,
14673                    background_area.height + 1);
14674   cairo_set_line_width (cr, 1.0);
14675   cairo_stroke (cr);
14676
14677   cairo_destroy (cr);
14678
14679   cairo_surface_set_device_offset (surface, 2, 2);
14680
14681   gtk_style_context_restore (context);
14682
14683   return surface;
14684 }
14685
14686
14687 /**
14688  * gtk_tree_view_set_destroy_count_func:
14689  * @tree_view: A #GtkTreeView
14690  * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
14691  * @data: (allow-none): User data to be passed to @func, or %NULL
14692  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14693  *
14694  * This function should almost never be used.  It is meant for private use by
14695  * ATK for determining the number of visible children that are removed when the
14696  * user collapses a row, or a row is deleted.
14697  *
14698  * Deprecated: 3.4: Accessibility does not need the function anymore.
14699  **/
14700 void
14701 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
14702                                       GtkTreeDestroyCountFunc  func,
14703                                       gpointer                 data,
14704                                       GDestroyNotify           destroy)
14705 {
14706   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14707
14708   if (tree_view->priv->destroy_count_destroy)
14709     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
14710
14711   tree_view->priv->destroy_count_func = func;
14712   tree_view->priv->destroy_count_data = data;
14713   tree_view->priv->destroy_count_destroy = destroy;
14714 }
14715
14716
14717 /*
14718  * Interactive search
14719  */
14720
14721 /**
14722  * gtk_tree_view_set_enable_search:
14723  * @tree_view: A #GtkTreeView
14724  * @enable_search: %TRUE, if the user can search interactively
14725  *
14726  * If @enable_search is set, then the user can type in text to search through
14727  * the tree interactively (this is sometimes called "typeahead find").
14728  *
14729  * Note that even if this is %FALSE, the user can still initiate a search
14730  * using the "start-interactive-search" key binding.
14731  */
14732 void
14733 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
14734                                  gboolean     enable_search)
14735 {
14736   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14737
14738   enable_search = !!enable_search;
14739
14740   if (tree_view->priv->enable_search != enable_search)
14741     {
14742        tree_view->priv->enable_search = enable_search;
14743        g_object_notify (G_OBJECT (tree_view), "enable-search");
14744     }
14745 }
14746
14747 /**
14748  * gtk_tree_view_get_enable_search:
14749  * @tree_view: A #GtkTreeView
14750  *
14751  * Returns whether or not the tree allows to start interactive searching
14752  * by typing in text.
14753  *
14754  * Return value: whether or not to let the user search interactively
14755  */
14756 gboolean
14757 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
14758 {
14759   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14760
14761   return tree_view->priv->enable_search;
14762 }
14763
14764
14765 /**
14766  * gtk_tree_view_get_search_column:
14767  * @tree_view: A #GtkTreeView
14768  *
14769  * Gets the column searched on by the interactive search code.
14770  *
14771  * Return value: the column the interactive search code searches in.
14772  */
14773 gint
14774 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
14775 {
14776   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
14777
14778   return (tree_view->priv->search_column);
14779 }
14780
14781 /**
14782  * gtk_tree_view_set_search_column:
14783  * @tree_view: A #GtkTreeView
14784  * @column: the column of the model to search in, or -1 to disable searching
14785  *
14786  * Sets @column as the column where the interactive search code should
14787  * search in for the current model.
14788  *
14789  * If the search column is set, users can use the "start-interactive-search"
14790  * key binding to bring up search popup. The enable-search property controls
14791  * whether simply typing text will also start an interactive search.
14792  *
14793  * Note that @column refers to a column of the current model. The search
14794  * column is reset to -1 when the model is changed.
14795  */
14796 void
14797 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
14798                                  gint         column)
14799 {
14800   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14801   g_return_if_fail (column >= -1);
14802
14803   if (tree_view->priv->search_column == column)
14804     return;
14805
14806   tree_view->priv->search_column = column;
14807   g_object_notify (G_OBJECT (tree_view), "search-column");
14808 }
14809
14810 /**
14811  * gtk_tree_view_get_search_equal_func: (skip)
14812  * @tree_view: A #GtkTreeView
14813  *
14814  * Returns the compare function currently in use.
14815  *
14816  * Return value: the currently used compare function for the search code.
14817  */
14818
14819 GtkTreeViewSearchEqualFunc
14820 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
14821 {
14822   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14823
14824   return tree_view->priv->search_equal_func;
14825 }
14826
14827 /**
14828  * gtk_tree_view_set_search_equal_func:
14829  * @tree_view: A #GtkTreeView
14830  * @search_equal_func: the compare function to use during the search
14831  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
14832  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
14833  *
14834  * Sets the compare function for the interactive search capabilities; note
14835  * that somewhat like strcmp() returning 0 for equality
14836  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
14837  **/
14838 void
14839 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14840                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14841                                      gpointer                    search_user_data,
14842                                      GDestroyNotify              search_destroy)
14843 {
14844   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14845   g_return_if_fail (search_equal_func != NULL);
14846
14847   if (tree_view->priv->search_destroy)
14848     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14849
14850   tree_view->priv->search_equal_func = search_equal_func;
14851   tree_view->priv->search_user_data = search_user_data;
14852   tree_view->priv->search_destroy = search_destroy;
14853   if (tree_view->priv->search_equal_func == NULL)
14854     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14855 }
14856
14857 /**
14858  * gtk_tree_view_get_search_entry:
14859  * @tree_view: A #GtkTreeView
14860  *
14861  * Returns the #GtkEntry which is currently in use as interactive search
14862  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14863  * will be returned.
14864  *
14865  * Return value: (transfer none): the entry currently in use as search entry.
14866  *
14867  * Since: 2.10
14868  */
14869 GtkEntry *
14870 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14871 {
14872   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14873
14874   if (tree_view->priv->search_custom_entry_set)
14875     return GTK_ENTRY (tree_view->priv->search_entry);
14876
14877   return NULL;
14878 }
14879
14880 /**
14881  * gtk_tree_view_set_search_entry:
14882  * @tree_view: A #GtkTreeView
14883  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
14884  *
14885  * Sets the entry which the interactive search code will use for this
14886  * @tree_view.  This is useful when you want to provide a search entry
14887  * in our interface at all time at a fixed position.  Passing %NULL for
14888  * @entry will make the interactive search code use the built-in popup
14889  * entry again.
14890  *
14891  * Since: 2.10
14892  */
14893 void
14894 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14895                                 GtkEntry    *entry)
14896 {
14897   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14898   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14899
14900   if (tree_view->priv->search_custom_entry_set)
14901     {
14902       if (tree_view->priv->search_entry_changed_id)
14903         {
14904           g_signal_handler_disconnect (tree_view->priv->search_entry,
14905                                        tree_view->priv->search_entry_changed_id);
14906           tree_view->priv->search_entry_changed_id = 0;
14907         }
14908       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14909                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14910                                             tree_view);
14911
14912       g_object_unref (tree_view->priv->search_entry);
14913     }
14914   else if (tree_view->priv->search_window)
14915     {
14916       gtk_widget_destroy (tree_view->priv->search_window);
14917
14918       tree_view->priv->search_window = NULL;
14919     }
14920
14921   if (entry)
14922     {
14923       tree_view->priv->search_entry = g_object_ref (entry);
14924       tree_view->priv->search_custom_entry_set = TRUE;
14925
14926       if (tree_view->priv->search_entry_changed_id == 0)
14927         {
14928           tree_view->priv->search_entry_changed_id =
14929             g_signal_connect (tree_view->priv->search_entry, "changed",
14930                               G_CALLBACK (gtk_tree_view_search_init),
14931                               tree_view);
14932         }
14933
14934         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14935                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14936                           tree_view);
14937
14938         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14939     }
14940   else
14941     {
14942       tree_view->priv->search_entry = NULL;
14943       tree_view->priv->search_custom_entry_set = FALSE;
14944     }
14945 }
14946
14947 /**
14948  * gtk_tree_view_set_search_position_func:
14949  * @tree_view: A #GtkTreeView
14950  * @func: (allow-none): the function to use to position the search dialog, or %NULL
14951  *    to use the default search position function
14952  * @data: (allow-none): user data to pass to @func, or %NULL
14953  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14954  *
14955  * Sets the function to use when positioning the search dialog.
14956  *
14957  * Since: 2.10
14958  **/
14959 void
14960 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
14961                                         GtkTreeViewSearchPositionFunc  func,
14962                                         gpointer                       user_data,
14963                                         GDestroyNotify                 destroy)
14964 {
14965   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14966
14967   if (tree_view->priv->search_position_destroy)
14968     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
14969
14970   tree_view->priv->search_position_func = func;
14971   tree_view->priv->search_position_user_data = user_data;
14972   tree_view->priv->search_position_destroy = destroy;
14973   if (tree_view->priv->search_position_func == NULL)
14974     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
14975 }
14976
14977 /**
14978  * gtk_tree_view_get_search_position_func: (skip)
14979  * @tree_view: A #GtkTreeView
14980  *
14981  * Returns the positioning function currently in use.
14982  *
14983  * Return value: the currently used function for positioning the search dialog.
14984  *
14985  * Since: 2.10
14986  */
14987 GtkTreeViewSearchPositionFunc
14988 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
14989 {
14990   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14991
14992   return tree_view->priv->search_position_func;
14993 }
14994
14995
14996 static void
14997 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
14998                                   GtkTreeView *tree_view,
14999                                   GdkDevice   *device)
15000 {
15001   if (tree_view->priv->disable_popdown)
15002     return;
15003
15004   if (tree_view->priv->search_entry_changed_id)
15005     {
15006       g_signal_handler_disconnect (tree_view->priv->search_entry,
15007                                    tree_view->priv->search_entry_changed_id);
15008       tree_view->priv->search_entry_changed_id = 0;
15009     }
15010   if (tree_view->priv->typeselect_flush_timeout)
15011     {
15012       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15013       tree_view->priv->typeselect_flush_timeout = 0;
15014     }
15015
15016   if (gtk_widget_get_visible (search_dialog))
15017     {
15018       /* send focus-in event */
15019       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
15020       gtk_widget_hide (search_dialog);
15021       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
15022       send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
15023     }
15024 }
15025
15026 static void
15027 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
15028                                     GtkWidget   *search_dialog,
15029                                     gpointer     user_data)
15030 {
15031   gint x, y;
15032   gint tree_x, tree_y;
15033   gint tree_width, tree_height;
15034   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
15035   GdkScreen *screen = gdk_window_get_screen (tree_window);
15036   GtkRequisition requisition;
15037   gint monitor_num;
15038   GdkRectangle monitor;
15039
15040   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
15041   gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
15042
15043   gtk_widget_realize (search_dialog);
15044
15045   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
15046   tree_width = gdk_window_get_width (tree_window);
15047   tree_height = gdk_window_get_height (tree_window);
15048   gtk_widget_get_preferred_size (search_dialog, &requisition, NULL);
15049
15050   if (tree_x + tree_width > gdk_screen_get_width (screen))
15051     x = gdk_screen_get_width (screen) - requisition.width;
15052   else if (tree_x + tree_width - requisition.width < 0)
15053     x = 0;
15054   else
15055     x = tree_x + tree_width - requisition.width;
15056
15057   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
15058     y = gdk_screen_get_height (screen) - requisition.height;
15059   else if (tree_y + tree_height < 0) /* isn't really possible ... */
15060     y = 0;
15061   else
15062     y = tree_y + tree_height;
15063
15064   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
15065 }
15066
15067 static void
15068 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
15069                                       GtkMenu  *menu,
15070                                       gpointer  data)
15071 {
15072   GtkTreeView *tree_view = (GtkTreeView *)data;
15073
15074   tree_view->priv->disable_popdown = 1;
15075   g_signal_connect (menu, "hide",
15076                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
15077 }
15078
15079 /* Because we're visible but offscreen, we just set a flag in the preedit
15080  * callback.
15081  */
15082 static void
15083 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
15084                                       GtkTreeView  *tree_view)
15085 {
15086   tree_view->priv->imcontext_changed = 1;
15087   if (tree_view->priv->typeselect_flush_timeout)
15088     {
15089       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15090       tree_view->priv->typeselect_flush_timeout =
15091         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15092                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15093                        tree_view);
15094     }
15095
15096 }
15097
15098 static void
15099 gtk_tree_view_search_activate (GtkEntry    *entry,
15100                                GtkTreeView *tree_view)
15101 {
15102   GtkTreePath *path;
15103
15104   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
15105                                     tree_view,
15106                                     gtk_get_current_event_device ());
15107
15108   /* If we have a row selected and it's the cursor row, we activate
15109    * the row XXX */
15110   if (tree_view->priv->cursor_node &&
15111       GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
15112     {
15113       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
15114                                              tree_view->priv->cursor_node);
15115
15116       gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
15117
15118       gtk_tree_path_free (path);
15119     }
15120 }
15121
15122 static gboolean
15123 gtk_tree_view_real_search_enable_popdown (gpointer data)
15124 {
15125   GtkTreeView *tree_view = (GtkTreeView *)data;
15126
15127   tree_view->priv->disable_popdown = 0;
15128
15129   return FALSE;
15130 }
15131
15132 static void
15133 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
15134                                      gpointer   data)
15135 {
15136   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
15137 }
15138
15139 static gboolean
15140 gtk_tree_view_search_delete_event (GtkWidget *widget,
15141                                    GdkEventAny *event,
15142                                    GtkTreeView *tree_view)
15143 {
15144   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15145
15146   gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
15147
15148   return TRUE;
15149 }
15150
15151 static gboolean
15152 gtk_tree_view_search_button_press_event (GtkWidget *widget,
15153                                          GdkEventButton *event,
15154                                          GtkTreeView *tree_view)
15155 {
15156   GdkDevice *keyb_device;
15157
15158   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15159
15160   keyb_device = gdk_device_get_associated_device (event->device);
15161   gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
15162
15163   if (event->window == tree_view->priv->bin_window)
15164     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
15165
15166   return TRUE;
15167 }
15168
15169 static gboolean
15170 gtk_tree_view_search_scroll_event (GtkWidget *widget,
15171                                    GdkEventScroll *event,
15172                                    GtkTreeView *tree_view)
15173 {
15174   gboolean retval = FALSE;
15175
15176   if (event->direction == GDK_SCROLL_UP)
15177     {
15178       gtk_tree_view_search_move (widget, tree_view, TRUE);
15179       retval = TRUE;
15180     }
15181   else if (event->direction == GDK_SCROLL_DOWN)
15182     {
15183       gtk_tree_view_search_move (widget, tree_view, FALSE);
15184       retval = TRUE;
15185     }
15186
15187   /* renew the flush timeout */
15188   if (retval && tree_view->priv->typeselect_flush_timeout
15189       && !tree_view->priv->search_custom_entry_set)
15190     {
15191       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15192       tree_view->priv->typeselect_flush_timeout =
15193         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15194                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15195                        tree_view);
15196     }
15197
15198   return retval;
15199 }
15200
15201 static gboolean
15202 gtk_tree_view_search_key_press_event (GtkWidget *widget,
15203                                       GdkEventKey *event,
15204                                       GtkTreeView *tree_view)
15205 {
15206   GdkModifierType default_accel;
15207   gboolean        retval = FALSE;
15208
15209   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15210   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15211
15212   /* close window and cancel the search */
15213   if (!tree_view->priv->search_custom_entry_set
15214       && (event->keyval == GDK_KEY_Escape ||
15215           event->keyval == GDK_KEY_Tab ||
15216             event->keyval == GDK_KEY_KP_Tab ||
15217             event->keyval == GDK_KEY_ISO_Left_Tab))
15218     {
15219       gtk_tree_view_search_dialog_hide (widget, tree_view,
15220                                         gdk_event_get_device ((GdkEvent *) event));
15221       return TRUE;
15222     }
15223
15224   default_accel = gtk_widget_get_modifier_mask (widget,
15225                                                 GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
15226
15227   /* select previous matching iter */
15228   if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
15229     {
15230       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15231         gtk_widget_error_bell (widget);
15232
15233       retval = TRUE;
15234     }
15235
15236   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == (default_accel | GDK_SHIFT_MASK))
15237       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15238     {
15239       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15240         gtk_widget_error_bell (widget);
15241
15242       retval = TRUE;
15243     }
15244
15245   /* select next matching iter */
15246   if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
15247     {
15248       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15249         gtk_widget_error_bell (widget);
15250
15251       retval = TRUE;
15252     }
15253
15254   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == default_accel)
15255       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15256     {
15257       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15258         gtk_widget_error_bell (widget);
15259
15260       retval = TRUE;
15261     }
15262
15263   /* renew the flush timeout */
15264   if (retval && tree_view->priv->typeselect_flush_timeout
15265       && !tree_view->priv->search_custom_entry_set)
15266     {
15267       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15268       tree_view->priv->typeselect_flush_timeout =
15269         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15270                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15271                        tree_view);
15272     }
15273
15274   return retval;
15275 }
15276
15277 /*  this function returns FALSE if there is a search string but
15278  *  nothing was found, and TRUE otherwise.
15279  */
15280 static gboolean
15281 gtk_tree_view_search_move (GtkWidget   *window,
15282                            GtkTreeView *tree_view,
15283                            gboolean     up)
15284 {
15285   gboolean ret;
15286   gint len;
15287   gint count = 0;
15288   const gchar *text;
15289   GtkTreeIter iter;
15290   GtkTreeModel *model;
15291   GtkTreeSelection *selection;
15292
15293   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
15294
15295   g_return_val_if_fail (text != NULL, FALSE);
15296
15297   len = strlen (text);
15298
15299   if (up && tree_view->priv->selected_iter == 1)
15300     return strlen (text) < 1;
15301
15302   len = strlen (text);
15303
15304   if (len < 1)
15305     return TRUE;
15306
15307   model = gtk_tree_view_get_model (tree_view);
15308   selection = gtk_tree_view_get_selection (tree_view);
15309
15310   /* search */
15311   gtk_tree_selection_unselect_all (selection);
15312   if (!gtk_tree_model_get_iter_first (model, &iter))
15313     return TRUE;
15314
15315   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
15316                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
15317
15318   if (ret)
15319     {
15320       /* found */
15321       tree_view->priv->selected_iter += up?(-1):(1);
15322       return TRUE;
15323     }
15324   else
15325     {
15326       /* return to old iter */
15327       count = 0;
15328       gtk_tree_model_get_iter_first (model, &iter);
15329       gtk_tree_view_search_iter (model, selection,
15330                                  &iter, text,
15331                                  &count, tree_view->priv->selected_iter);
15332       return FALSE;
15333     }
15334 }
15335
15336 static gboolean
15337 gtk_tree_view_search_equal_func (GtkTreeModel *model,
15338                                  gint          column,
15339                                  const gchar  *key,
15340                                  GtkTreeIter  *iter,
15341                                  gpointer      search_data)
15342 {
15343   gboolean retval = TRUE;
15344   const gchar *str;
15345   gchar *normalized_string;
15346   gchar *normalized_key;
15347   gchar *case_normalized_string = NULL;
15348   gchar *case_normalized_key = NULL;
15349   GValue value = G_VALUE_INIT;
15350   GValue transformed = G_VALUE_INIT;
15351
15352   gtk_tree_model_get_value (model, iter, column, &value);
15353
15354   g_value_init (&transformed, G_TYPE_STRING);
15355
15356   if (!g_value_transform (&value, &transformed))
15357     {
15358       g_value_unset (&value);
15359       return TRUE;
15360     }
15361
15362   g_value_unset (&value);
15363
15364   str = g_value_get_string (&transformed);
15365   if (!str)
15366     {
15367       g_value_unset (&transformed);
15368       return TRUE;
15369     }
15370
15371   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
15372   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
15373
15374   if (normalized_string && normalized_key)
15375     {
15376       case_normalized_string = g_utf8_casefold (normalized_string, -1);
15377       case_normalized_key = g_utf8_casefold (normalized_key, -1);
15378
15379       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
15380         retval = FALSE;
15381     }
15382
15383   g_value_unset (&transformed);
15384   g_free (normalized_key);
15385   g_free (normalized_string);
15386   g_free (case_normalized_key);
15387   g_free (case_normalized_string);
15388
15389   return retval;
15390 }
15391
15392 static gboolean
15393 gtk_tree_view_search_iter (GtkTreeModel     *model,
15394                            GtkTreeSelection *selection,
15395                            GtkTreeIter      *iter,
15396                            const gchar      *text,
15397                            gint             *count,
15398                            gint              n)
15399 {
15400   GtkRBTree *tree = NULL;
15401   GtkRBNode *node = NULL;
15402   GtkTreePath *path;
15403
15404   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
15405
15406   path = gtk_tree_model_get_path (model, iter);
15407   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15408
15409   do
15410     {
15411       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
15412         {
15413           (*count)++;
15414           if (*count == n)
15415             {
15416               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
15417                                             TRUE, 0.5, 0.0);
15418               gtk_tree_selection_select_iter (selection, iter);
15419               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15420
15421               if (path)
15422                 gtk_tree_path_free (path);
15423
15424               return TRUE;
15425             }
15426         }
15427
15428       if (node->children)
15429         {
15430           gboolean has_child;
15431           GtkTreeIter tmp;
15432
15433           tree = node->children;
15434           node = _gtk_rbtree_first (tree);
15435
15436           tmp = *iter;
15437           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
15438           gtk_tree_path_down (path);
15439
15440           /* sanity check */
15441           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
15442         }
15443       else
15444         {
15445           gboolean done = FALSE;
15446
15447           do
15448             {
15449               node = _gtk_rbtree_next (tree, node);
15450
15451               if (node)
15452                 {
15453                   gboolean has_next;
15454
15455                   has_next = gtk_tree_model_iter_next (model, iter);
15456
15457                   done = TRUE;
15458                   gtk_tree_path_next (path);
15459
15460                   /* sanity check */
15461                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
15462                 }
15463               else
15464                 {
15465                   gboolean has_parent;
15466                   GtkTreeIter tmp_iter = *iter;
15467
15468                   node = tree->parent_node;
15469                   tree = tree->parent_tree;
15470
15471                   if (!tree)
15472                     {
15473                       if (path)
15474                         gtk_tree_path_free (path);
15475
15476                       /* we've run out of tree, done with this func */
15477                       return FALSE;
15478                     }
15479
15480                   has_parent = gtk_tree_model_iter_parent (model,
15481                                                            iter,
15482                                                            &tmp_iter);
15483                   gtk_tree_path_up (path);
15484
15485                   /* sanity check */
15486                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
15487                 }
15488             }
15489           while (!done);
15490         }
15491     }
15492   while (1);
15493
15494   return FALSE;
15495 }
15496
15497 static void
15498 gtk_tree_view_search_init (GtkWidget   *entry,
15499                            GtkTreeView *tree_view)
15500 {
15501   gint ret;
15502   gint count = 0;
15503   const gchar *text;
15504   GtkTreeIter iter;
15505   GtkTreeModel *model;
15506   GtkTreeSelection *selection;
15507
15508   g_return_if_fail (GTK_IS_ENTRY (entry));
15509   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15510
15511   text = gtk_entry_get_text (GTK_ENTRY (entry));
15512
15513   model = gtk_tree_view_get_model (tree_view);
15514   selection = gtk_tree_view_get_selection (tree_view);
15515
15516   /* search */
15517   gtk_tree_selection_unselect_all (selection);
15518   if (tree_view->priv->typeselect_flush_timeout
15519       && !tree_view->priv->search_custom_entry_set)
15520     {
15521       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15522       tree_view->priv->typeselect_flush_timeout =
15523         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15524                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15525                        tree_view);
15526     }
15527
15528   if (*text == '\0')
15529     return;
15530
15531   if (!gtk_tree_model_get_iter_first (model, &iter))
15532     return;
15533
15534   ret = gtk_tree_view_search_iter (model, selection,
15535                                    &iter, text,
15536                                    &count, 1);
15537
15538   if (ret)
15539     tree_view->priv->selected_iter = 1;
15540 }
15541
15542 void
15543 _gtk_tree_view_remove_editable (GtkTreeView       *tree_view,
15544                                 GtkTreeViewColumn *column,
15545                                 GtkCellEditable   *cell_editable)
15546 {
15547   if (tree_view->priv->edited_column == NULL)
15548     return;
15549
15550   g_return_if_fail (column == tree_view->priv->edited_column);
15551
15552   tree_view->priv->edited_column = NULL;
15553
15554   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
15555     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
15556
15557   gtk_container_remove (GTK_CONTAINER (tree_view),
15558                         GTK_WIDGET (cell_editable));
15559
15560   /* FIXME should only redraw a single node */
15561   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15562 }
15563
15564 static gboolean
15565 gtk_tree_view_start_editing (GtkTreeView *tree_view,
15566                              GtkTreePath *cursor_path,
15567                              gboolean     edit_only)
15568 {
15569   GtkTreeIter iter;
15570   GdkRectangle cell_area;
15571   GtkTreeViewColumn *focus_column;
15572   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
15573   gint retval = FALSE;
15574   GtkRBTree *cursor_tree;
15575   GtkRBNode *cursor_node;
15576
15577   g_assert (tree_view->priv->focus_column);
15578   focus_column = tree_view->priv->focus_column;
15579
15580   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
15581     return FALSE;
15582
15583   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
15584       cursor_node == NULL)
15585     return FALSE;
15586
15587   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
15588
15589   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
15590
15591   gtk_tree_view_column_cell_set_cell_data (focus_column,
15592                                            tree_view->priv->model,
15593                                            &iter,
15594                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
15595                                            cursor_node->children ? TRUE : FALSE);
15596   gtk_tree_view_get_cell_area (tree_view,
15597                                cursor_path,
15598                                focus_column,
15599                                &cell_area);
15600
15601   if (gtk_cell_area_activate (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (focus_column)),
15602                               _gtk_tree_view_column_get_context (focus_column),
15603                               GTK_WIDGET (tree_view),
15604                               &cell_area,
15605                               flags, edit_only))
15606     retval = TRUE;
15607
15608   return retval;
15609 }
15610
15611 void
15612 _gtk_tree_view_add_editable (GtkTreeView       *tree_view,
15613                              GtkTreeViewColumn *column,
15614                              GtkTreePath       *path,
15615                              GtkCellEditable   *cell_editable,
15616                              GdkRectangle      *cell_area)
15617 {
15618   gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
15619   GtkRequisition requisition;
15620
15621   tree_view->priv->edited_column = column;
15622
15623   gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15624   cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
15625
15626   gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
15627                                  &requisition, NULL);
15628
15629   tree_view->priv->draw_keyfocus = TRUE;
15630
15631   if (requisition.height < cell_area->height)
15632     {
15633       gint diff = cell_area->height - requisition.height;
15634       gtk_tree_view_put (tree_view,
15635                          GTK_WIDGET (cell_editable),
15636                          cell_area->x, cell_area->y + diff/2,
15637                          cell_area->width, requisition.height);
15638     }
15639   else
15640     {
15641       gtk_tree_view_put (tree_view,
15642                          GTK_WIDGET (cell_editable),
15643                          cell_area->x, cell_area->y,
15644                          cell_area->width, cell_area->height);
15645     }
15646 }
15647
15648 static void
15649 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
15650                             gboolean     cancel_editing)
15651 {
15652   GtkTreeViewColumn *column;
15653
15654   if (tree_view->priv->edited_column == NULL)
15655     return;
15656
15657   /*
15658    * This is very evil. We need to do this, because
15659    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
15660    * later on. If gtk_tree_view_row_changed notices
15661    * tree_view->priv->edited_column != NULL, it'll call
15662    * gtk_tree_view_stop_editing again. Bad things will happen then.
15663    *
15664    * Please read that again if you intend to modify anything here.
15665    */
15666
15667   column = tree_view->priv->edited_column;
15668   gtk_cell_area_stop_editing (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)), cancel_editing);
15669   tree_view->priv->edited_column = NULL;
15670 }
15671
15672
15673 /**
15674  * gtk_tree_view_set_hover_selection:
15675  * @tree_view: a #GtkTreeView
15676  * @hover: %TRUE to enable hover selection mode
15677  *
15678  * Enables or disables the hover selection mode of @tree_view.
15679  * Hover selection makes the selected row follow the pointer.
15680  * Currently, this works only for the selection modes
15681  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
15682  *
15683  * Since: 2.6
15684  **/
15685 void
15686 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
15687                                    gboolean     hover)
15688 {
15689   hover = hover != FALSE;
15690
15691   if (hover != tree_view->priv->hover_selection)
15692     {
15693       tree_view->priv->hover_selection = hover;
15694
15695       g_object_notify (G_OBJECT (tree_view), "hover-selection");
15696     }
15697 }
15698
15699 /**
15700  * gtk_tree_view_get_hover_selection:
15701  * @tree_view: a #GtkTreeView
15702  *
15703  * Returns whether hover selection mode is turned on for @tree_view.
15704  *
15705  * Return value: %TRUE if @tree_view is in hover selection mode
15706  *
15707  * Since: 2.6
15708  **/
15709 gboolean
15710 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
15711 {
15712   return tree_view->priv->hover_selection;
15713 }
15714
15715 /**
15716  * gtk_tree_view_set_hover_expand:
15717  * @tree_view: a #GtkTreeView
15718  * @expand: %TRUE to enable hover selection mode
15719  *
15720  * Enables or disables the hover expansion mode of @tree_view.
15721  * Hover expansion makes rows expand or collapse if the pointer
15722  * moves over them.
15723  *
15724  * Since: 2.6
15725  **/
15726 void
15727 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
15728                                 gboolean     expand)
15729 {
15730   expand = expand != FALSE;
15731
15732   if (expand != tree_view->priv->hover_expand)
15733     {
15734       tree_view->priv->hover_expand = expand;
15735
15736       g_object_notify (G_OBJECT (tree_view), "hover-expand");
15737     }
15738 }
15739
15740 /**
15741  * gtk_tree_view_get_hover_expand:
15742  * @tree_view: a #GtkTreeView
15743  *
15744  * Returns whether hover expansion mode is turned on for @tree_view.
15745  *
15746  * Return value: %TRUE if @tree_view is in hover expansion mode
15747  *
15748  * Since: 2.6
15749  **/
15750 gboolean
15751 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
15752 {
15753   return tree_view->priv->hover_expand;
15754 }
15755
15756 /**
15757  * gtk_tree_view_set_rubber_banding:
15758  * @tree_view: a #GtkTreeView
15759  * @enable: %TRUE to enable rubber banding
15760  *
15761  * Enables or disables rubber banding in @tree_view.  If the selection mode
15762  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
15763  * multiple rows by dragging the mouse.
15764  *
15765  * Since: 2.10
15766  **/
15767 void
15768 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
15769                                   gboolean     enable)
15770 {
15771   enable = enable != FALSE;
15772
15773   if (enable != tree_view->priv->rubber_banding_enable)
15774     {
15775       tree_view->priv->rubber_banding_enable = enable;
15776
15777       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
15778     }
15779 }
15780
15781 /**
15782  * gtk_tree_view_get_rubber_banding:
15783  * @tree_view: a #GtkTreeView
15784  *
15785  * Returns whether rubber banding is turned on for @tree_view.  If the
15786  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15787  * user to select multiple rows by dragging the mouse.
15788  *
15789  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15790  *
15791  * Since: 2.10
15792  **/
15793 gboolean
15794 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15795 {
15796   return tree_view->priv->rubber_banding_enable;
15797 }
15798
15799 /**
15800  * gtk_tree_view_is_rubber_banding_active:
15801  * @tree_view: a #GtkTreeView
15802  *
15803  * Returns whether a rubber banding operation is currently being done
15804  * in @tree_view.
15805  *
15806  * Return value: %TRUE if a rubber banding operation is currently being
15807  * done in @tree_view.
15808  *
15809  * Since: 2.12
15810  **/
15811 gboolean
15812 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15813 {
15814   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15815
15816   if (tree_view->priv->rubber_banding_enable
15817       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15818     return TRUE;
15819
15820   return FALSE;
15821 }
15822
15823 /**
15824  * gtk_tree_view_get_row_separator_func: (skip)
15825  * @tree_view: a #GtkTreeView
15826  *
15827  * Returns the current row separator function.
15828  *
15829  * Return value: the current row separator function.
15830  *
15831  * Since: 2.6
15832  **/
15833 GtkTreeViewRowSeparatorFunc
15834 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15835 {
15836   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15837
15838   return tree_view->priv->row_separator_func;
15839 }
15840
15841 /**
15842  * gtk_tree_view_set_row_separator_func:
15843  * @tree_view: a #GtkTreeView
15844  * @func: (allow-none): a #GtkTreeViewRowSeparatorFunc
15845  * @data: (allow-none): user data to pass to @func, or %NULL
15846  * @destroy: (allow-none): destroy notifier for @data, or %NULL
15847  *
15848  * Sets the row separator function, which is used to determine
15849  * whether a row should be drawn as a separator. If the row separator
15850  * function is %NULL, no separators are drawn. This is the default value.
15851  *
15852  * Since: 2.6
15853  **/
15854 void
15855 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15856                                       GtkTreeViewRowSeparatorFunc  func,
15857                                       gpointer                     data,
15858                                       GDestroyNotify               destroy)
15859 {
15860   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15861
15862   if (tree_view->priv->row_separator_destroy)
15863     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15864
15865   tree_view->priv->row_separator_func = func;
15866   tree_view->priv->row_separator_data = data;
15867   tree_view->priv->row_separator_destroy = destroy;
15868
15869   /* Have the tree recalculate heights */
15870   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15871   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15872 }
15873
15874
15875 static void
15876 gtk_tree_view_grab_notify (GtkWidget *widget,
15877                            gboolean   was_grabbed)
15878 {
15879   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15880
15881   tree_view->priv->in_grab = !was_grabbed;
15882
15883   if (!was_grabbed)
15884     {
15885       tree_view->priv->pressed_button = -1;
15886
15887       if (tree_view->priv->rubber_band_status)
15888         gtk_tree_view_stop_rubber_band (tree_view);
15889     }
15890 }
15891
15892 static void
15893 gtk_tree_view_state_flags_changed (GtkWidget     *widget,
15894                                    GtkStateFlags  previous_state)
15895 {
15896   if (gtk_widget_get_realized (widget))
15897     gtk_tree_view_ensure_background (GTK_TREE_VIEW (widget));
15898
15899   gtk_widget_queue_draw (widget);
15900 }
15901
15902 /**
15903  * gtk_tree_view_get_grid_lines:
15904  * @tree_view: a #GtkTreeView
15905  *
15906  * Returns which grid lines are enabled in @tree_view.
15907  *
15908  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15909  * are enabled.
15910  *
15911  * Since: 2.10
15912  */
15913 GtkTreeViewGridLines
15914 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15915 {
15916   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15917
15918   return tree_view->priv->grid_lines;
15919 }
15920
15921 /**
15922  * gtk_tree_view_set_grid_lines:
15923  * @tree_view: a #GtkTreeView
15924  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15925  * enable.
15926  *
15927  * Sets which grid lines to draw in @tree_view.
15928  *
15929  * Since: 2.10
15930  */
15931 void
15932 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15933                               GtkTreeViewGridLines   grid_lines)
15934 {
15935   GtkTreeViewPrivate *priv;
15936   GtkWidget *widget;
15937   GtkTreeViewGridLines old_grid_lines;
15938
15939   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15940
15941   priv = tree_view->priv;
15942   widget = GTK_WIDGET (tree_view);
15943
15944   old_grid_lines = priv->grid_lines;
15945   priv->grid_lines = grid_lines;
15946
15947   if (gtk_widget_get_realized (widget))
15948     {
15949       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15950           priv->grid_line_width)
15951         {
15952           priv->grid_line_width = 0;
15953         }
15954
15955       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15956           !priv->grid_line_width)
15957         {
15958           gint8 *dash_list;
15959
15960           gtk_widget_style_get (widget,
15961                                 "grid-line-width", &priv->grid_line_width,
15962                                 "grid-line-pattern", (gchar *)&dash_list,
15963                                 NULL);
15964
15965           if (dash_list)
15966             {
15967               priv->grid_line_dashes[0] = dash_list[0];
15968               if (dash_list[0])
15969                 priv->grid_line_dashes[1] = dash_list[1];
15970
15971               g_free (dash_list);
15972             }
15973           else
15974             {
15975               priv->grid_line_dashes[0] = 1;
15976               priv->grid_line_dashes[1] = 1;
15977             }
15978         }
15979     }
15980
15981   if (old_grid_lines != grid_lines)
15982     {
15983       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15984
15985       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
15986     }
15987 }
15988
15989 /**
15990  * gtk_tree_view_get_enable_tree_lines:
15991  * @tree_view: a #GtkTreeView.
15992  *
15993  * Returns whether or not tree lines are drawn in @tree_view.
15994  *
15995  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
15996  * otherwise.
15997  *
15998  * Since: 2.10
15999  */
16000 gboolean
16001 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
16002 {
16003   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16004
16005   return tree_view->priv->tree_lines_enabled;
16006 }
16007
16008 /**
16009  * gtk_tree_view_set_enable_tree_lines:
16010  * @tree_view: a #GtkTreeView
16011  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
16012  *
16013  * Sets whether to draw lines interconnecting the expanders in @tree_view.
16014  * This does not have any visible effects for lists.
16015  *
16016  * Since: 2.10
16017  */
16018 void
16019 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
16020                                      gboolean     enabled)
16021 {
16022   GtkTreeViewPrivate *priv;
16023   GtkWidget *widget;
16024   gboolean was_enabled;
16025
16026   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16027
16028   enabled = enabled != FALSE;
16029
16030   priv = tree_view->priv;
16031   widget = GTK_WIDGET (tree_view);
16032
16033   was_enabled = priv->tree_lines_enabled;
16034
16035   priv->tree_lines_enabled = enabled;
16036
16037   if (gtk_widget_get_realized (widget))
16038     {
16039       if (!enabled && priv->tree_line_width)
16040         {
16041           priv->tree_line_width = 0;
16042         }
16043
16044       if (enabled && !priv->tree_line_width)
16045         {
16046           gint8 *dash_list;
16047           gtk_widget_style_get (widget,
16048                                 "tree-line-width", &priv->tree_line_width,
16049                                 "tree-line-pattern", (gchar *)&dash_list,
16050                                 NULL);
16051
16052           if (dash_list)
16053             {
16054               priv->tree_line_dashes[0] = dash_list[0];
16055               if (dash_list[0])
16056                 priv->tree_line_dashes[1] = dash_list[1];
16057
16058               g_free (dash_list);
16059             }
16060           else
16061             {
16062               priv->tree_line_dashes[0] = 1;
16063               priv->tree_line_dashes[1] = 1;
16064             }
16065         }
16066     }
16067
16068   if (was_enabled != enabled)
16069     {
16070       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16071
16072       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
16073     }
16074 }
16075
16076
16077 /**
16078  * gtk_tree_view_set_show_expanders:
16079  * @tree_view: a #GtkTreeView
16080  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
16081  *
16082  * Sets whether to draw and enable expanders and indent child rows in
16083  * @tree_view.  When disabled there will be no expanders visible in trees
16084  * and there will be no way to expand and collapse rows by default.  Also
16085  * note that hiding the expanders will disable the default indentation.  You
16086  * can set a custom indentation in this case using
16087  * gtk_tree_view_set_level_indentation().
16088  * This does not have any visible effects for lists.
16089  *
16090  * Since: 2.12
16091  */
16092 void
16093 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
16094                                   gboolean     enabled)
16095 {
16096   gboolean was_enabled;
16097
16098   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16099
16100   enabled = enabled != FALSE;
16101   was_enabled = tree_view->priv->show_expanders;
16102
16103   tree_view->priv->show_expanders = enabled == TRUE;
16104
16105   if (enabled != was_enabled)
16106     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16107 }
16108
16109 /**
16110  * gtk_tree_view_get_show_expanders:
16111  * @tree_view: a #GtkTreeView.
16112  *
16113  * Returns whether or not expanders are drawn in @tree_view.
16114  *
16115  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
16116  * otherwise.
16117  *
16118  * Since: 2.12
16119  */
16120 gboolean
16121 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
16122 {
16123   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16124
16125   return tree_view->priv->show_expanders;
16126 }
16127
16128 /**
16129  * gtk_tree_view_set_level_indentation:
16130  * @tree_view: a #GtkTreeView
16131  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
16132  *
16133  * Sets the amount of extra indentation for child levels to use in @tree_view
16134  * in addition to the default indentation.  The value should be specified in
16135  * pixels, a value of 0 disables this feature and in this case only the default
16136  * indentation will be used.
16137  * This does not have any visible effects for lists.
16138  *
16139  * Since: 2.12
16140  */
16141 void
16142 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
16143                                      gint         indentation)
16144 {
16145   tree_view->priv->level_indentation = indentation;
16146
16147   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16148 }
16149
16150 /**
16151  * gtk_tree_view_get_level_indentation:
16152  * @tree_view: a #GtkTreeView.
16153  *
16154  * Returns the amount, in pixels, of extra indentation for child levels
16155  * in @tree_view.
16156  *
16157  * Return value: the amount of extra indentation for child levels in
16158  * @tree_view.  A return value of 0 means that this feature is disabled.
16159  *
16160  * Since: 2.12
16161  */
16162 gint
16163 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
16164 {
16165   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16166
16167   return tree_view->priv->level_indentation;
16168 }
16169
16170 /**
16171  * gtk_tree_view_set_tooltip_row:
16172  * @tree_view: a #GtkTreeView
16173  * @tooltip: a #GtkTooltip
16174  * @path: a #GtkTreePath
16175  *
16176  * Sets the tip area of @tooltip to be the area covered by the row at @path.
16177  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16178  * See also gtk_tooltip_set_tip_area().
16179  *
16180  * Since: 2.12
16181  */
16182 void
16183 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
16184                                GtkTooltip  *tooltip,
16185                                GtkTreePath *path)
16186 {
16187   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16188   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16189
16190   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
16191 }
16192
16193 /**
16194  * gtk_tree_view_set_tooltip_cell:
16195  * @tree_view: a #GtkTreeView
16196  * @tooltip: a #GtkTooltip
16197  * @path: (allow-none): a #GtkTreePath or %NULL
16198  * @column: (allow-none): a #GtkTreeViewColumn or %NULL
16199  * @cell: (allow-none): a #GtkCellRenderer or %NULL
16200  *
16201  * Sets the tip area of @tooltip to the area @path, @column and @cell have
16202  * in common.  For example if @path is %NULL and @column is set, the tip
16203  * area will be set to the full area covered by @column.  See also
16204  * gtk_tooltip_set_tip_area().
16205  *
16206  * Note that if @path is not specified and @cell is set and part of a column
16207  * containing the expander, the tooltip might not show and hide at the correct
16208  * position.  In such cases @path must be set to the current node under the
16209  * mouse cursor for this function to operate correctly.
16210  *
16211  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16212  *
16213  * Since: 2.12
16214  */
16215 void
16216 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
16217                                 GtkTooltip        *tooltip,
16218                                 GtkTreePath       *path,
16219                                 GtkTreeViewColumn *column,
16220                                 GtkCellRenderer   *cell)
16221 {
16222   GtkAllocation allocation;
16223   GdkRectangle rect;
16224
16225   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16226   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16227   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
16228   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
16229
16230   /* Determine x values. */
16231   if (column && cell)
16232     {
16233       GdkRectangle tmp;
16234       gint start, width;
16235
16236       /* We always pass in path here, whether it is NULL or not.
16237        * For cells in expander columns path must be specified so that
16238        * we can correctly account for the indentation.  This also means
16239        * that the tooltip is constrained vertically by the "Determine y
16240        * values" code below; this is not a real problem since cells actually
16241        * don't stretch vertically in constrast to columns.
16242        */
16243       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
16244       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
16245
16246       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16247                                                          tmp.x + start, 0,
16248                                                          &rect.x, NULL);
16249       rect.width = width;
16250     }
16251   else if (column)
16252     {
16253       GdkRectangle tmp;
16254
16255       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
16256       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16257                                                          tmp.x, 0,
16258                                                          &rect.x, NULL);
16259       rect.width = tmp.width;
16260     }
16261   else
16262     {
16263       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
16264       rect.x = 0;
16265       rect.width = allocation.width;
16266     }
16267
16268   /* Determine y values. */
16269   if (path)
16270     {
16271       GdkRectangle tmp;
16272
16273       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
16274       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16275                                                          0, tmp.y,
16276                                                          NULL, &rect.y);
16277       rect.height = tmp.height;
16278     }
16279   else
16280     {
16281       rect.y = 0;
16282       rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
16283     }
16284
16285   gtk_tooltip_set_tip_area (tooltip, &rect);
16286 }
16287
16288 /**
16289  * gtk_tree_view_get_tooltip_context:
16290  * @tree_view: a #GtkTreeView
16291  * @x: (inout): the x coordinate (relative to widget coordinates)
16292  * @y: (inout): the y coordinate (relative to widget coordinates)
16293  * @keyboard_tip: whether this is a keyboard tooltip or not
16294  * @model: (out) (allow-none) (transfer none): a pointer to receive a
16295  *         #GtkTreeModel or %NULL
16296  * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
16297  * @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
16298  *
16299  * This function is supposed to be used in a #GtkWidget::query-tooltip
16300  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
16301  * which are received in the signal handler, should be passed to this
16302  * function without modification.
16303  *
16304  * The return value indicates whether there is a tree view row at the given
16305  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
16306  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
16307  * @model, @path and @iter which have been provided will be set to point to
16308  * that row and the corresponding model.  @x and @y will always be converted
16309  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
16310  *
16311  * Return value: whether or not the given tooltip context points to a row.
16312  *
16313  * Since: 2.12
16314  */
16315 gboolean
16316 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
16317                                    gint          *x,
16318                                    gint          *y,
16319                                    gboolean       keyboard_tip,
16320                                    GtkTreeModel **model,
16321                                    GtkTreePath  **path,
16322                                    GtkTreeIter   *iter)
16323 {
16324   GtkTreePath *tmppath = NULL;
16325
16326   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16327   g_return_val_if_fail (x != NULL, FALSE);
16328   g_return_val_if_fail (y != NULL, FALSE);
16329
16330   if (keyboard_tip)
16331     {
16332       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
16333
16334       if (!tmppath)
16335         return FALSE;
16336     }
16337   else
16338     {
16339       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
16340                                                          x, y);
16341
16342       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
16343                                           &tmppath, NULL, NULL, NULL))
16344         return FALSE;
16345     }
16346
16347   if (model)
16348     *model = gtk_tree_view_get_model (tree_view);
16349
16350   if (iter)
16351     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
16352                              iter, tmppath);
16353
16354   if (path)
16355     *path = tmppath;
16356   else
16357     gtk_tree_path_free (tmppath);
16358
16359   return TRUE;
16360 }
16361
16362 static gboolean
16363 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
16364                                     gint        x,
16365                                     gint        y,
16366                                     gboolean    keyboard_tip,
16367                                     GtkTooltip *tooltip,
16368                                     gpointer    data)
16369 {
16370   GValue value = G_VALUE_INIT;
16371   GValue transformed = G_VALUE_INIT;
16372   GtkTreeIter iter;
16373   GtkTreePath *path;
16374   GtkTreeModel *model;
16375   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
16376
16377   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
16378                                           &x, &y,
16379                                           keyboard_tip,
16380                                           &model, &path, &iter))
16381     return FALSE;
16382
16383   gtk_tree_model_get_value (model, &iter,
16384                             tree_view->priv->tooltip_column, &value);
16385
16386   g_value_init (&transformed, G_TYPE_STRING);
16387
16388   if (!g_value_transform (&value, &transformed))
16389     {
16390       g_value_unset (&value);
16391       gtk_tree_path_free (path);
16392
16393       return FALSE;
16394     }
16395
16396   g_value_unset (&value);
16397
16398   if (!g_value_get_string (&transformed))
16399     {
16400       g_value_unset (&transformed);
16401       gtk_tree_path_free (path);
16402
16403       return FALSE;
16404     }
16405
16406   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
16407   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
16408
16409   gtk_tree_path_free (path);
16410   g_value_unset (&transformed);
16411
16412   return TRUE;
16413 }
16414
16415 /**
16416  * gtk_tree_view_set_tooltip_column:
16417  * @tree_view: a #GtkTreeView
16418  * @column: an integer, which is a valid column number for @tree_view's model
16419  *
16420  * If you only plan to have simple (text-only) tooltips on full rows, you
16421  * can use this function to have #GtkTreeView handle these automatically
16422  * for you. @column should be set to the column in @tree_view's model
16423  * containing the tooltip texts, or -1 to disable this feature.
16424  *
16425  * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
16426  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
16427  *
16428  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
16429  * so &amp;, &lt;, etc have to be escaped in the text.
16430  *
16431  * Since: 2.12
16432  */
16433 void
16434 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
16435                                   gint         column)
16436 {
16437   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16438
16439   if (column == tree_view->priv->tooltip_column)
16440     return;
16441
16442   if (column == -1)
16443     {
16444       g_signal_handlers_disconnect_by_func (tree_view,
16445                                             gtk_tree_view_set_tooltip_query_cb,
16446                                             NULL);
16447       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
16448     }
16449   else
16450     {
16451       if (tree_view->priv->tooltip_column == -1)
16452         {
16453           g_signal_connect (tree_view, "query-tooltip",
16454                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
16455           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
16456         }
16457     }
16458
16459   tree_view->priv->tooltip_column = column;
16460   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
16461 }
16462
16463 /**
16464  * gtk_tree_view_get_tooltip_column:
16465  * @tree_view: a #GtkTreeView
16466  *
16467  * Returns the column of @tree_view's model which is being used for
16468  * displaying tooltips on @tree_view's rows.
16469  *
16470  * Return value: the index of the tooltip column that is currently being
16471  * used, or -1 if this is disabled.
16472  *
16473  * Since: 2.12
16474  */
16475 gint
16476 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
16477 {
16478   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16479
16480   return tree_view->priv->tooltip_column;
16481 }