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 "gtkcssstylepropertyprivate.h"
  52 #include "gtktypebuiltins.h"
  53 #include "gtkmain.h"
  54 #include "gtksettings.h"
  55 #include "gtkwidgetpath.h"
  56 #include "a11y/gtktreeviewaccessibleprivate.h"
  57
  58
  59 /**
  60  * SECTION:gtktreeview
  61  * @Short_description: A widget for displaying both trees and lists
  62  * @Title: GtkTreeView
  63  * @See_also: #GtkTreeViewColumn, #GtkTreeSelection, #GtkTreeDnd, #GtkTreeMode,
  64  *   #GtkTreeSortable, #GtkTreeModelSort, #GtkListStore, #GtkTreeStore,
  65  *   #GtkCellRenderer, #GtkCellEditable, #GtkCellRendererPixbuf,
  66  *   #GtkCellRendererText, #GtkCellRendererToggle
  67  *
  68  * Widget that displays any object that implements the #GtkTreeModel interface.
  69  *
  70  * Please refer to the <link linkend="TreeWidget">tree widget conceptual
  71  * overview</link> for an overview of all the objects and data types related
  72  * to the tree widget and how they work together.
  73  *
  74  * Several different coordinate systems are exposed in the GtkTreeView API.
  75  * These are:
  76  *
  77  * <inlinegraphic fileref="tree-view-coordinates.png" format="PNG"></inlinegraphic>
  78  * <variablelist><title>Coordinate systems in GtkTreeView API</title>
  79  * <varlistentry><term>Widget coordinates</term>
  80  * <listitem>
  81  * <para>
  82  * Coordinates relative to the widget (usually <literal>widget->window</literal>).
  83  * </para>
  84  * </listitem>
  85  * </varlistentry>
  86  * <varlistentry><term>Bin window coordinates</term>
  87  * <listitem>
  88  * <para>
  89  * Coordinates relative to the window that GtkTreeView renders to.
  90  * </para>
  91  * </listitem>
  92  * </varlistentry>
  93  * <varlistentry><term>Tree coordinates</term>
  94  * <listitem>
  95  * <para>
  96  * Coordinates relative to the entire scrollable area of GtkTreeView. These
  97  * coordinates start at (0, 0) for row 0 of the tree.
  98  * </para>
  99  * </listitem>
 100  * </varlistentry>
 101  * </variablelist>
 102  *
 103  * Several functions are available for converting between the different
 104  * coordinate systems.  The most common translations are between widget and bin
 105  * window coordinates and between bin window and tree coordinates. For the
 106  * former you can use gtk_tree_view_convert_widget_to_bin_window_coords()
 107  * (and vice versa), for the latter gtk_tree_view_convert_bin_window_to_tree_coords()
 108  * (and vice versa).
 109  *
 110  * <refsect2 id="GtkTreeView-BUILDER-UI">
 111  * <title>GtkTreeView as GtkBuildable</title>
 112  * The GtkTreeView implementation of the GtkBuildable interface accepts
 113  * #GtkTreeViewColumn objects as &lt;child&gt; elements and exposes the
 114  * internal #GtkTreeSelection in UI definitions.
 115  * <example>
 116  * <title>A UI definition fragment with GtkTreeView</title>
 117  * <programlisting><![CDATA[
 118  * <object class="GtkTreeView" id="treeview">
 119  *   <property name="model">liststore1</property>
 120  *   <child>
 121  *     <object class="GtkTreeViewColumn" id="test-column">
 122  *       <property name="title">Test</property>
 123  *       <child>
 124  *         <object class="GtkCellRendererText" id="test-renderer"/>
 125  *         <attributes>
 126  *           <attribute name="text">1</attribute>
 127  *         </attributes>
 128  *       </child>
 129  *     </object>
 130  *   </child>
 131  *   <child internal-child="selection">
 132  *     <object class="GtkTreeSelection" id="selection">
 133  *       <signal name="changed" handler="on_treeview_selection_changed"/>
 134  *     </object>
 135  *   </child>
 136  * </object>
 137  * ]]></programlisting>
 138  * </example>
 139  * </refsect2>
 140  */
 141
 142 enum
 143 {
 144   DRAG_COLUMN_WINDOW_STATE_UNSET = 0,
 145   DRAG_COLUMN_WINDOW_STATE_ORIGINAL = 1,
 146   DRAG_COLUMN_WINDOW_STATE_ARROW = 2,
 147   DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT = 3,
 148   DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT = 4
 149 };
 150
 151 enum
 152 {
 153   RUBBER_BAND_OFF = 0,
 154   RUBBER_BAND_MAYBE_START = 1,
 155   RUBBER_BAND_ACTIVE = 2
 156 };
 157
 158 typedef enum {
 159   CLEAR_AND_SELECT = (1 << 0),
 160   CLAMP_NODE       = (1 << 1),
 161   CURSOR_INVALID   = (1 << 2)
 162 } SetCursorFlags;
 163
 164  /* This lovely little value is used to determine how far away from the title bar
 165   * you can move the mouse and still have a column drag work.
 166   */
 167 #define TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER(tree_view) (10*gtk_tree_view_get_effective_header_height(tree_view))
 168
 169 #ifdef __GNUC__
 170
 171 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 172      if (!(expr))                                                       \
 173        {                                                                \
 174          g_log (G_LOG_DOMAIN,                                           \
 175                 G_LOG_LEVEL_CRITICAL,                                   \
 176                 "%s (%s): assertion `%s' failed.\n"                     \
 177                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 178                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 179                 "without letting the view know.  Any display from now on is likely to\n"  \
 180                 "be incorrect.\n",                                                        \
 181                 G_STRLOC,                                               \
 182                 G_STRFUNC,                                              \
 183                 #expr);                                                 \
 184          return ret;                                                    \
 185        };                               }G_STMT_END
 186
 187 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 188      if (!(expr))                                                       \
 189        {                                                                \
 190          g_log (G_LOG_DOMAIN,                                           \
 191                 G_LOG_LEVEL_CRITICAL,                                   \
 192                 "%s (%s): assertion `%s' failed.\n"                     \
 193                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 194                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 195                 "without letting the view know.  Any display from now on is likely to\n"  \
 196                 "be incorrect.\n",                                                        \
 197                 G_STRLOC,                                               \
 198                 G_STRFUNC,                                              \
 199                 #expr);                                                 \
 200          return;                                                        \
 201        };                               }G_STMT_END
 202
 203 #else
 204
 205 #define TREE_VIEW_INTERNAL_ASSERT(expr, ret)     G_STMT_START{          \
 206      if (!(expr))                                                       \
 207        {                                                                \
 208          g_log (G_LOG_DOMAIN,                                           \
 209                 G_LOG_LEVEL_CRITICAL,                                   \
 210                 "file %s: line %d: assertion `%s' failed.\n"       \
 211                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 212                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 213                 "without letting the view know.  Any display from now on is likely to\n"  \
 214                 "be incorrect.\n",                                                        \
 215                 __FILE__,                                               \
 216                 __LINE__,                                               \
 217                 #expr);                                                 \
 218          return ret;                                                    \
 219        };                               }G_STMT_END
 220
 221 #define TREE_VIEW_INTERNAL_ASSERT_VOID(expr)     G_STMT_START{          \
 222      if (!(expr))                                                       \
 223        {                                                                \
 224          g_log (G_LOG_DOMAIN,                                           \
 225                 G_LOG_LEVEL_CRITICAL,                                   \
 226                 "file %s: line %d: assertion '%s' failed.\n"            \
 227                 "There is a disparity between the internal view of the GtkTreeView,\n"    \
 228                 "and the GtkTreeModel.  This generally means that the model has changed\n"\
 229                 "without letting the view know.  Any display from now on is likely to\n"  \
 230                 "be incorrect.\n",                                                        \
 231                 __FILE__,                                               \
 232                 __LINE__,                                               \
 233                 #expr);                                                 \
 234          return;                                                        \
 235        };                               }G_STMT_END
 236 #endif
 237
 238 #define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
 239 #define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2)
 240 #define GTK_TREE_VIEW_TIME_MS_PER_IDLE 30
 241 #define SCROLL_EDGE_SIZE 15
 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   /* Column width allocation */
 388   gint minimum_width;
 389   gint natural_width;
 390   gint n_expand_columns;
 391
 392   /* ATK Hack */
 393   GtkTreeDestroyCountFunc destroy_count_func;
 394   gpointer destroy_count_data;
 395   GDestroyNotify destroy_count_destroy;
 396
 397   /* Scroll timeout (e.g. during dnd, rubber banding) */
 398   guint scroll_timeout;
 399
 400   /* Row drag-and-drop */
 401   GtkTreeRowReference *drag_dest_row;
 402   GtkTreeViewDropPosition drag_dest_pos;
 403   guint open_dest_timeout;
 404
 405   /* Rubber banding */
 406   gint rubber_band_status;
 407   gint rubber_band_x;
 408   gint rubber_band_y;
 409   gint rubber_band_extend;
 410   gint rubber_band_modify;
 411
 412   GtkRBNode *rubber_band_start_node;
 413   GtkRBTree *rubber_band_start_tree;
 414
 415   GtkRBNode *rubber_band_end_node;
 416   GtkRBTree *rubber_band_end_tree;
 417
 418   /* fixed height */
 419   gint fixed_height;
 420
 421   /* Scroll-to functionality when unrealized */
 422   GtkTreeRowReference *scroll_to_path;
 423   GtkTreeViewColumn *scroll_to_column;
 424   gfloat scroll_to_row_align;
 425   gfloat scroll_to_col_align;
 426
 427   /* Interactive search */
 428   gint selected_iter;
 429   gint search_column;
 430   GtkTreeViewSearchPositionFunc search_position_func;
 431   GtkTreeViewSearchEqualFunc search_equal_func;
 432   gpointer search_user_data;
 433   GDestroyNotify search_destroy;
 434   gpointer search_position_user_data;
 435   GDestroyNotify search_position_destroy;
 436   GtkWidget *search_window;
 437   GtkWidget *search_entry;
 438   gulong search_entry_changed_id;
 439   guint typeselect_flush_timeout;
 440
 441   /* Grid and tree lines */
 442   GtkTreeViewGridLines grid_lines;
 443   double grid_line_dashes[2];
 444   int grid_line_width;
 445
 446   gboolean tree_lines_enabled;
 447   double tree_line_dashes[2];
 448   int tree_line_width;
 449
 450   /* Row separators */
 451   GtkTreeViewRowSeparatorFunc row_separator_func;
 452   gpointer row_separator_data;
 453   GDestroyNotify row_separator_destroy;
 454
 455   /* Tooltip support */
 456   gint tooltip_column;
 457
 458   /* Here comes the bitfield */
 459   guint scroll_to_use_align : 1;
 460
 461   guint fixed_height_mode : 1;
 462   guint fixed_height_check : 1;
 463
 464   guint activate_on_single_click : 1;
 465   guint reorderable : 1;
 466   guint header_has_focus : 1;
 467   guint drag_column_window_state : 3;
 468   /* hint to display rows in alternating colors */
 469   guint has_rules : 1;
 470   guint mark_rows_col_dirty : 1;
 471
 472   /* for DnD */
 473   guint empty_view_drop : 1;
 474
 475   guint modify_selection_pressed : 1;
 476   guint extend_selection_pressed : 1;
 477
 478   guint init_hadjust_value : 1;
 479
 480   guint in_top_row_to_dy : 1;
 481
 482   /* interactive search */
 483   guint enable_search : 1;
 484   guint disable_popdown : 1;
 485   guint search_custom_entry_set : 1;
 486
 487   guint hover_selection : 1;
 488   guint hover_expand : 1;
 489   guint imcontext_changed : 1;
 490
 491   guint rubber_banding_enable : 1;
 492
 493   guint in_grab : 1;
 494
 495   /* Whether our key press handler is to avoid sending an unhandled binding to the search entry */
 496   guint search_entry_avoid_unhandled_binding : 1;
 497
 498   /* GtkScrollablePolicy needs to be checked when
 499    * driving the scrollable adjustment values */
 500   guint hscroll_policy : 1;
 501   guint vscroll_policy : 1;
 502
 503   /* GtkTreeView flags */
 504   guint is_list : 1;
 505   guint show_expanders : 1;
 506   guint in_column_resize : 1;
 507   guint arrow_prelit : 1;
 508   guint headers_visible : 1;
 509   guint draw_keyfocus : 1;
 510   guint model_setup : 1;
 511   guint in_column_drag : 1;
 512 };
 513
 514
 515 /* Signals */
 516 enum
 517 {
 518   ROW_ACTIVATED,
 519   TEST_EXPAND_ROW,
 520   TEST_COLLAPSE_ROW,
 521   ROW_EXPANDED,
 522   ROW_COLLAPSED,
 523   COLUMNS_CHANGED,
 524   CURSOR_CHANGED,
 525   MOVE_CURSOR,
 526   SELECT_ALL,
 527   UNSELECT_ALL,
 528   SELECT_CURSOR_ROW,
 529   TOGGLE_CURSOR_ROW,
 530   EXPAND_COLLAPSE_CURSOR_ROW,
 531   SELECT_CURSOR_PARENT,
 532   START_INTERACTIVE_SEARCH,
 533   LAST_SIGNAL
 534 };
 535
 536 /* Properties */
 537 enum {
 538   PROP_0,
 539   PROP_MODEL,
 540   PROP_HADJUSTMENT,
 541   PROP_VADJUSTMENT,
 542   PROP_HSCROLL_POLICY,
 543   PROP_VSCROLL_POLICY,
 544   PROP_HEADERS_VISIBLE,
 545   PROP_HEADERS_CLICKABLE,
 546   PROP_EXPANDER_COLUMN,
 547   PROP_REORDERABLE,
 548   PROP_RULES_HINT,
 549   PROP_ENABLE_SEARCH,
 550   PROP_SEARCH_COLUMN,
 551   PROP_FIXED_HEIGHT_MODE,
 552   PROP_HOVER_SELECTION,
 553   PROP_HOVER_EXPAND,
 554   PROP_SHOW_EXPANDERS,
 555   PROP_LEVEL_INDENTATION,
 556   PROP_RUBBER_BANDING,
 557   PROP_ENABLE_GRID_LINES,
 558   PROP_ENABLE_TREE_LINES,
 559   PROP_TOOLTIP_COLUMN,
 560   PROP_ACTIVATE_ON_SINGLE_CLICK
 561 };
 562
 563 /* object signals */
 564 static void     gtk_tree_view_finalize             (GObject          *object);
 565 static void     gtk_tree_view_set_property         (GObject         *object,
 566                                                     guint            prop_id,
 567                                                     const GValue    *value,
 568                                                     GParamSpec      *pspec);
 569 static void     gtk_tree_view_get_property         (GObject         *object,
 570                                                     guint            prop_id,
 571                                                     GValue          *value,
 572                                                     GParamSpec      *pspec);
 573
 574 /* gtkwidget signals */
 575 static void     gtk_tree_view_destroy              (GtkWidget        *widget);
 576 static void     gtk_tree_view_realize              (GtkWidget        *widget);
 577 static void     gtk_tree_view_unrealize            (GtkWidget        *widget);
 578 static void     gtk_tree_view_map                  (GtkWidget        *widget);
 579 static void     gtk_tree_view_get_preferred_width  (GtkWidget        *widget,
 580                                                     gint             *minimum,
 581                                                     gint             *natural);
 582 static void     gtk_tree_view_get_preferred_height (GtkWidget        *widget,
 583                                                     gint             *minimum,
 584                                                     gint             *natural);
 585 static void     gtk_tree_view_size_allocate        (GtkWidget        *widget,
 586                                                     GtkAllocation    *allocation);
 587 static gboolean gtk_tree_view_draw                 (GtkWidget        *widget,
 588                                                     cairo_t          *cr);
 589 static gboolean gtk_tree_view_key_press            (GtkWidget        *widget,
 590                                                     GdkEventKey      *event);
 591 static gboolean gtk_tree_view_key_release          (GtkWidget        *widget,
 592                                                     GdkEventKey      *event);
 593 static gboolean gtk_tree_view_motion               (GtkWidget        *widget,
 594                                                     GdkEventMotion   *event);
 595 static gboolean gtk_tree_view_enter_notify         (GtkWidget        *widget,
 596                                                     GdkEventCrossing *event);
 597 static gboolean gtk_tree_view_leave_notify         (GtkWidget        *widget,
 598                                                     GdkEventCrossing *event);
 599 static gboolean gtk_tree_view_button_press         (GtkWidget        *widget,
 600                                                     GdkEventButton   *event);
 601 static gboolean gtk_tree_view_button_release       (GtkWidget        *widget,
 602                                                     GdkEventButton   *event);
 603 static gboolean gtk_tree_view_grab_broken          (GtkWidget          *widget,
 604                                                     GdkEventGrabBroken *event);
 605 #if 0
 606 static gboolean gtk_tree_view_configure            (GtkWidget         *widget,
 607                                                     GdkEventConfigure *event);
 608 #endif
 609
 610 static GtkWidgetPath * gtk_tree_view_get_path_for_child (GtkContainer *container,
 611                                                          GtkWidget    *child);
 612
 613 static void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 614                                                     GtkWidget        *child);
 615 static gint     gtk_tree_view_focus_out            (GtkWidget        *widget,
 616                                                     GdkEventFocus    *event);
 617 static gint     gtk_tree_view_focus                (GtkWidget        *widget,
 618                                                     GtkDirectionType  direction);
 619 static void     gtk_tree_view_grab_focus           (GtkWidget        *widget);
 620 static void     gtk_tree_view_style_updated        (GtkWidget        *widget);
 621 static void     gtk_tree_view_grab_notify          (GtkWidget        *widget,
 622                                                     gboolean          was_grabbed);
 623 static void     gtk_tree_view_state_flags_changed  (GtkWidget        *widget,
 624                                                     GtkStateFlags     previous_state);
 625
 626 /* container signals */
 627 static void     gtk_tree_view_remove               (GtkContainer     *container,
 628                                                     GtkWidget        *widget);
 629 static void     gtk_tree_view_forall               (GtkContainer     *container,
 630                                                     gboolean          include_internals,
 631                                                     GtkCallback       callback,
 632                                                     gpointer          callback_data);
 633
 634 /* Source side drag signals */
 635 static void gtk_tree_view_drag_begin       (GtkWidget        *widget,
 636                                             GdkDragContext   *context);
 637 static void gtk_tree_view_drag_end         (GtkWidget        *widget,
 638                                             GdkDragContext   *context);
 639 static void gtk_tree_view_drag_data_get    (GtkWidget        *widget,
 640                                             GdkDragContext   *context,
 641                                             GtkSelectionData *selection_data,
 642                                             guint             info,
 643                                             guint             time);
 644 static void gtk_tree_view_drag_data_delete (GtkWidget        *widget,
 645                                             GdkDragContext   *context);
 646
 647 /* Target side drag signals */
 648 static void     gtk_tree_view_drag_leave         (GtkWidget        *widget,
 649                                                   GdkDragContext   *context,
 650                                                   guint             time);
 651 static gboolean gtk_tree_view_drag_motion        (GtkWidget        *widget,
 652                                                   GdkDragContext   *context,
 653                                                   gint              x,
 654                                                   gint              y,
 655                                                   guint             time);
 656 static gboolean gtk_tree_view_drag_drop          (GtkWidget        *widget,
 657                                                   GdkDragContext   *context,
 658                                                   gint              x,
 659                                                   gint              y,
 660                                                   guint             time);
 661 static void     gtk_tree_view_drag_data_received (GtkWidget        *widget,
 662                                                   GdkDragContext   *context,
 663                                                   gint              x,
 664                                                   gint              y,
 665                                                   GtkSelectionData *selection_data,
 666                                                   guint             info,
 667                                                   guint             time);
 668
 669 /* tree_model signals */
 670 static gboolean gtk_tree_view_real_move_cursor            (GtkTreeView     *tree_view,
 671                                                            GtkMovementStep  step,
 672                                                            gint             count);
 673 static gboolean gtk_tree_view_real_select_all             (GtkTreeView     *tree_view);
 674 static gboolean gtk_tree_view_real_unselect_all           (GtkTreeView     *tree_view);
 675 static gboolean gtk_tree_view_real_select_cursor_row      (GtkTreeView     *tree_view,
 676                                                            gboolean         start_editing);
 677 static gboolean gtk_tree_view_real_toggle_cursor_row      (GtkTreeView     *tree_view);
 678 static gboolean gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView     *tree_view,
 679                                                                gboolean         logical,
 680                                                                gboolean         expand,
 681                                                                gboolean         open_all);
 682 static gboolean gtk_tree_view_real_select_cursor_parent   (GtkTreeView     *tree_view);
 683 static void gtk_tree_view_row_changed                     (GtkTreeModel    *model,
 684                                                            GtkTreePath     *path,
 685                                                            GtkTreeIter     *iter,
 686                                                            gpointer         data);
 687 static void gtk_tree_view_row_inserted                    (GtkTreeModel    *model,
 688                                                            GtkTreePath     *path,
 689                                                            GtkTreeIter     *iter,
 690                                                            gpointer         data);
 691 static void gtk_tree_view_row_has_child_toggled           (GtkTreeModel    *model,
 692                                                            GtkTreePath     *path,
 693                                                            GtkTreeIter     *iter,
 694                                                            gpointer         data);
 695 static void gtk_tree_view_row_deleted                     (GtkTreeModel    *model,
 696                                                            GtkTreePath     *path,
 697                                                            gpointer         data);
 698 static void gtk_tree_view_rows_reordered                  (GtkTreeModel    *model,
 699                                                            GtkTreePath     *parent,
 700                                                            GtkTreeIter     *iter,
 701                                                            gint            *new_order,
 702                                                            gpointer         data);
 703
 704 /* Incremental reflow */
 705 static gboolean validate_row             (GtkTreeView *tree_view,
 706                                           GtkRBTree   *tree,
 707                                           GtkRBNode   *node,
 708                                           GtkTreeIter *iter,
 709                                           GtkTreePath *path);
 710 static void     validate_visible_area    (GtkTreeView *tree_view);
 711 static gboolean validate_rows_handler    (GtkTreeView *tree_view);
 712 static gboolean do_validate_rows         (GtkTreeView *tree_view,
 713                                           gboolean     queue_resize);
 714 static gboolean validate_rows            (GtkTreeView *tree_view);
 715 static gboolean presize_handler_callback (gpointer     data);
 716 static void     install_presize_handler  (GtkTreeView *tree_view);
 717 static void     install_scroll_sync_handler (GtkTreeView *tree_view);
 718 static void     gtk_tree_view_set_top_row   (GtkTreeView *tree_view,
 719                                              GtkTreePath *path,
 720                                              gint         offset);
 721 static void     gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view);
 722 static void     gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view);
 723 static void     invalidate_empty_focus      (GtkTreeView *tree_view);
 724
 725 /* Internal functions */
 726 static gboolean gtk_tree_view_is_expander_column             (GtkTreeView        *tree_view,
 727                                                               GtkTreeViewColumn  *column);
 728 static inline gboolean gtk_tree_view_draw_expanders          (GtkTreeView        *tree_view);
 729 static void     gtk_tree_view_add_move_binding               (GtkBindingSet      *binding_set,
 730                                                               guint               keyval,
 731                                                               guint               modmask,
 732                                                               gboolean            add_shifted_binding,
 733                                                               GtkMovementStep     step,
 734                                                               gint                count);
 735 static gint     gtk_tree_view_unref_and_check_selection_tree (GtkTreeView        *tree_view,
 736                                                               GtkRBTree          *tree);
 737 static void     gtk_tree_view_queue_draw_path                (GtkTreeView        *tree_view,
 738                                                               GtkTreePath        *path,
 739                                                               const GdkRectangle *clip_rect);
 740 static void     gtk_tree_view_queue_draw_arrow               (GtkTreeView        *tree_view,
 741                                                               GtkRBTree          *tree,
 742                                                               GtkRBNode          *node);
 743 static void     gtk_tree_view_draw_arrow                     (GtkTreeView        *tree_view,
 744                                                               cairo_t            *cr,
 745                                                               GtkRBTree          *tree,
 746                                                               GtkRBNode          *node);
 747 static void     gtk_tree_view_get_arrow_xrange               (GtkTreeView        *tree_view,
 748                                                               GtkRBTree          *tree,
 749                                                               gint               *x1,
 750                                                               gint               *x2);
 751 static void     gtk_tree_view_adjustment_changed             (GtkAdjustment      *adjustment,
 752                                                               GtkTreeView        *tree_view);
 753 static void     gtk_tree_view_build_tree                     (GtkTreeView        *tree_view,
 754                                                               GtkRBTree          *tree,
 755                                                               GtkTreeIter        *iter,
 756                                                               gint                depth,
 757                                                               gboolean            recurse);
 758 static void     gtk_tree_view_clamp_node_visible             (GtkTreeView        *tree_view,
 759                                                               GtkRBTree          *tree,
 760                                                               GtkRBNode          *node);
 761 static void     gtk_tree_view_clamp_column_visible           (GtkTreeView        *tree_view,
 762                                                               GtkTreeViewColumn  *column,
 763                                                               gboolean            focus_to_cell);
 764 static gboolean gtk_tree_view_maybe_begin_dragging_row       (GtkTreeView        *tree_view,
 765                                                               GdkEventMotion     *event);
 766 static void     gtk_tree_view_focus_to_cursor                (GtkTreeView        *tree_view);
 767 static void     gtk_tree_view_move_cursor_up_down            (GtkTreeView        *tree_view,
 768                                                               gint                count);
 769 static void     gtk_tree_view_move_cursor_page_up_down       (GtkTreeView        *tree_view,
 770                                                               gint                count);
 771 static void     gtk_tree_view_move_cursor_left_right         (GtkTreeView        *tree_view,
 772                                                               gint                count);
 773 static void     gtk_tree_view_move_cursor_start_end          (GtkTreeView        *tree_view,
 774                                                               gint                count);
 775 static gboolean gtk_tree_view_real_collapse_row              (GtkTreeView        *tree_view,
 776                                                               GtkTreePath        *path,
 777                                                               GtkRBTree          *tree,
 778                                                               GtkRBNode          *node,
 779                                                               gboolean            animate);
 780 static gboolean gtk_tree_view_real_expand_row                (GtkTreeView        *tree_view,
 781                                                               GtkTreePath        *path,
 782                                                               GtkRBTree          *tree,
 783                                                               GtkRBNode          *node,
 784                                                               gboolean            open_all,
 785                                                               gboolean            animate);
 786 static void     gtk_tree_view_real_set_cursor                (GtkTreeView        *tree_view,
 787                                                               GtkTreePath        *path,
 788                                                               SetCursorFlags      flags);
 789 static gboolean gtk_tree_view_has_can_focus_cell             (GtkTreeView        *tree_view);
 790 static void     column_sizing_notify                         (GObject            *object,
 791                                                               GParamSpec         *pspec,
 792                                                               gpointer            data);
 793 static void     gtk_tree_view_stop_rubber_band               (GtkTreeView        *tree_view);
 794 static void     update_prelight                              (GtkTreeView        *tree_view,
 795                                                               int                 x,
 796                                                               int                 y);
 797
 798 static inline gint gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view);
 799
 800 static inline gint gtk_tree_view_get_cell_area_y_offset      (GtkTreeView *tree_view,
 801                                                               GtkRBTree   *tree,
 802                                                               GtkRBNode   *node,
 803                                                               gint         vertical_separator);
 804 static inline gint gtk_tree_view_get_cell_area_height        (GtkTreeView *tree_view,
 805                                                               GtkRBNode   *node,
 806                                                               gint         vertical_separator);
 807
 808 static inline gint gtk_tree_view_get_row_y_offset            (GtkTreeView *tree_view,
 809                                                               GtkRBTree   *tree,
 810                                                               GtkRBNode   *node);
 811 static inline gint gtk_tree_view_get_row_height              (GtkTreeView *tree_view,
 812                                                               GtkRBNode   *node);
 813
 814 /* interactive search */
 815 static void     gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view);
 816 static void     gtk_tree_view_search_dialog_hide        (GtkWidget        *search_dialog,
 817                                                          GtkTreeView      *tree_view,
 818                                                          GdkDevice        *device);
 819 static void     gtk_tree_view_search_position_func      (GtkTreeView      *tree_view,
 820                                                          GtkWidget        *search_dialog,
 821                                                          gpointer          user_data);
 822 static void     gtk_tree_view_search_disable_popdown    (GtkEntry         *entry,
 823                                                          GtkMenu          *menu,
 824                                                          gpointer          data);
 825 static void     gtk_tree_view_search_preedit_changed    (GtkIMContext     *im_context,
 826                                                          GtkTreeView      *tree_view);
 827 static void     gtk_tree_view_search_activate           (GtkEntry         *entry,
 828                                                          GtkTreeView      *tree_view);
 829 static gboolean gtk_tree_view_real_search_enable_popdown(gpointer          data);
 830 static void     gtk_tree_view_search_enable_popdown     (GtkWidget        *widget,
 831                                                          gpointer          data);
 832 static gboolean gtk_tree_view_search_delete_event       (GtkWidget        *widget,
 833                                                          GdkEventAny      *event,
 834                                                          GtkTreeView      *tree_view);
 835 static gboolean gtk_tree_view_search_button_press_event (GtkWidget        *widget,
 836                                                          GdkEventButton   *event,
 837                                                          GtkTreeView      *tree_view);
 838 static gboolean gtk_tree_view_search_scroll_event       (GtkWidget        *entry,
 839                                                          GdkEventScroll   *event,
 840                                                          GtkTreeView      *tree_view);
 841 static gboolean gtk_tree_view_search_key_press_event    (GtkWidget        *entry,
 842                                                          GdkEventKey      *event,
 843                                                          GtkTreeView      *tree_view);
 844 static gboolean gtk_tree_view_search_move               (GtkWidget        *window,
 845                                                          GtkTreeView      *tree_view,
 846                                                          gboolean          up);
 847 static gboolean gtk_tree_view_search_equal_func         (GtkTreeModel     *model,
 848                                                          gint              column,
 849                                                          const gchar      *key,
 850                                                          GtkTreeIter      *iter,
 851                                                          gpointer          search_data);
 852 static gboolean gtk_tree_view_search_iter               (GtkTreeModel     *model,
 853                                                          GtkTreeSelection *selection,
 854                                                          GtkTreeIter      *iter,
 855                                                          const gchar      *text,
 856                                                          gint             *count,
 857                                                          gint              n);
 858 static void     gtk_tree_view_search_init               (GtkWidget        *entry,
 859                                                          GtkTreeView      *tree_view);
 860 static void     gtk_tree_view_put                       (GtkTreeView      *tree_view,
 861                                                          GtkWidget        *child_widget,
 862                                                          gint              x,
 863                                                          gint              y,
 864                                                          gint              width,
 865                                                          gint              height);
 866 static gboolean gtk_tree_view_start_editing             (GtkTreeView      *tree_view,
 867                                                          GtkTreePath      *cursor_path,
 868                                                          gboolean          edit_only);
 869 static void gtk_tree_view_stop_editing                  (GtkTreeView *tree_view,
 870                                                          gboolean     cancel_editing);
 871 static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
 872                                                              GdkDevice   *device,
 873                                                              gboolean     keybinding);
 874 static gboolean gtk_tree_view_start_interactive_search      (GtkTreeView *tree_view);
 875 static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
 876                                                          GtkTreeViewColumn *column,
 877                                                          gint               drop_position);
 878
 879 /* GtkBuildable */
 880 static void     gtk_tree_view_buildable_add_child          (GtkBuildable      *tree_view,
 881                                                             GtkBuilder        *builder,
 882                                                             GObject           *child,
 883                                                             const gchar       *type);
 884 static GObject *gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
 885                                                             GtkBuilder        *builder,
 886                                                             const gchar       *childname);
 887 static void     gtk_tree_view_buildable_init               (GtkBuildableIface *iface);
 888
 889 static GtkAdjustment *gtk_tree_view_do_get_hadjustment (GtkTreeView   *tree_view);
 890 static void           gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
 891                                                         GtkAdjustment *adjustment);
 892 static GtkAdjustment *gtk_tree_view_do_get_vadjustment (GtkTreeView   *tree_view);
 893 static void           gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
 894                                                         GtkAdjustment *adjustment);
 895
 896 static gboolean scroll_row_timeout                   (gpointer     data);
 897 static void     add_scroll_timeout                   (GtkTreeView *tree_view);
 898 static void     remove_scroll_timeout                (GtkTreeView *tree_view);
 899
 900 static guint tree_view_signals [LAST_SIGNAL] = { 0 };
 901
 902 \f
 903
 904 /* GType Methods
 905  */
 906
 907 G_DEFINE_TYPE_WITH_CODE (GtkTreeView, gtk_tree_view, GTK_TYPE_CONTAINER,
 908                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 909                                                 gtk_tree_view_buildable_init)
 910                          G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
 911
 912 static void
 913 gtk_tree_view_class_init (GtkTreeViewClass *class)
 914 {
 915   GObjectClass *o_class;
 916   GtkWidgetClass *widget_class;
 917   GtkContainerClass *container_class;
 918   GtkBindingSet *binding_set;
 919
 920   binding_set = gtk_binding_set_by_class (class);
 921
 922   o_class = (GObjectClass *) class;
 923   widget_class = (GtkWidgetClass *) class;
 924   container_class = (GtkContainerClass *) class;
 925
 926   /* GObject signals */
 927   o_class->set_property = gtk_tree_view_set_property;
 928   o_class->get_property = gtk_tree_view_get_property;
 929   o_class->finalize = gtk_tree_view_finalize;
 930
 931   /* GtkWidget signals */
 932   widget_class->destroy = gtk_tree_view_destroy;
 933   widget_class->map = gtk_tree_view_map;
 934   widget_class->realize = gtk_tree_view_realize;
 935   widget_class->unrealize = gtk_tree_view_unrealize;
 936   widget_class->get_preferred_width = gtk_tree_view_get_preferred_width;
 937   widget_class->get_preferred_height = gtk_tree_view_get_preferred_height;
 938   widget_class->size_allocate = gtk_tree_view_size_allocate;
 939   widget_class->button_press_event = gtk_tree_view_button_press;
 940   widget_class->button_release_event = gtk_tree_view_button_release;
 941   widget_class->grab_broken_event = gtk_tree_view_grab_broken;
 942   /*widget_class->configure_event = gtk_tree_view_configure;*/
 943   widget_class->motion_notify_event = gtk_tree_view_motion;
 944   widget_class->draw = gtk_tree_view_draw;
 945   widget_class->key_press_event = gtk_tree_view_key_press;
 946   widget_class->key_release_event = gtk_tree_view_key_release;
 947   widget_class->enter_notify_event = gtk_tree_view_enter_notify;
 948   widget_class->leave_notify_event = gtk_tree_view_leave_notify;
 949   widget_class->focus_out_event = gtk_tree_view_focus_out;
 950   widget_class->drag_begin = gtk_tree_view_drag_begin;
 951   widget_class->drag_end = gtk_tree_view_drag_end;
 952   widget_class->drag_data_get = gtk_tree_view_drag_data_get;
 953   widget_class->drag_data_delete = gtk_tree_view_drag_data_delete;
 954   widget_class->drag_leave = gtk_tree_view_drag_leave;
 955   widget_class->drag_motion = gtk_tree_view_drag_motion;
 956   widget_class->drag_drop = gtk_tree_view_drag_drop;
 957   widget_class->drag_data_received = gtk_tree_view_drag_data_received;
 958   widget_class->focus = gtk_tree_view_focus;
 959   widget_class->grab_focus = gtk_tree_view_grab_focus;
 960   widget_class->style_updated = gtk_tree_view_style_updated;
 961   widget_class->grab_notify = gtk_tree_view_grab_notify;
 962   widget_class->state_flags_changed = gtk_tree_view_state_flags_changed;
 963
 964   /* GtkContainer signals */
 965   container_class->remove = gtk_tree_view_remove;
 966   container_class->forall = gtk_tree_view_forall;
 967   container_class->set_focus_child = gtk_tree_view_set_focus_child;
 968   container_class->get_path_for_child = gtk_tree_view_get_path_for_child;
 969
 970   class->move_cursor = gtk_tree_view_real_move_cursor;
 971   class->select_all = gtk_tree_view_real_select_all;
 972   class->unselect_all = gtk_tree_view_real_unselect_all;
 973   class->select_cursor_row = gtk_tree_view_real_select_cursor_row;
 974   class->toggle_cursor_row = gtk_tree_view_real_toggle_cursor_row;
 975   class->expand_collapse_cursor_row = gtk_tree_view_real_expand_collapse_cursor_row;
 976   class->select_cursor_parent = gtk_tree_view_real_select_cursor_parent;
 977   class->start_interactive_search = gtk_tree_view_start_interactive_search;
 978
 979   /* Properties */
 980
 981   g_object_class_install_property (o_class,
 982                                    PROP_MODEL,
 983                                    g_param_spec_object ("model",
 984                                                         P_("TreeView Model"),
 985                                                         P_("The model for the tree view"),
 986                                                         GTK_TYPE_TREE_MODEL,
 987                                                         GTK_PARAM_READWRITE));
 988
 989   g_object_class_override_property (o_class, PROP_HADJUSTMENT,    "hadjustment");
 990   g_object_class_override_property (o_class, PROP_VADJUSTMENT,    "vadjustment");
 991   g_object_class_override_property (o_class, PROP_HSCROLL_POLICY, "hscroll-policy");
 992   g_object_class_override_property (o_class, PROP_VSCROLL_POLICY, "vscroll-policy");
 993
 994   g_object_class_install_property (o_class,
 995                                    PROP_HEADERS_VISIBLE,
 996                                    g_param_spec_boolean ("headers-visible",
 997                                                          P_("Headers Visible"),
 998                                                          P_("Show the column header buttons"),
 999                                                          TRUE,
1000                                                          GTK_PARAM_READWRITE));
1001
1002   g_object_class_install_property (o_class,
1003                                    PROP_HEADERS_CLICKABLE,
1004                                    g_param_spec_boolean ("headers-clickable",
1005                                                          P_("Headers Clickable"),
1006                                                          P_("Column headers respond to click events"),
1007                                                          TRUE,
1008                                                          GTK_PARAM_READWRITE));
1009
1010   g_object_class_install_property (o_class,
1011                                    PROP_EXPANDER_COLUMN,
1012                                    g_param_spec_object ("expander-column",
1013                                                         P_("Expander Column"),
1014                                                         P_("Set the column for the expander column"),
1015                                                         GTK_TYPE_TREE_VIEW_COLUMN,
1016                                                         GTK_PARAM_READWRITE));
1017
1018   g_object_class_install_property (o_class,
1019                                    PROP_REORDERABLE,
1020                                    g_param_spec_boolean ("reorderable",
1021                                                          P_("Reorderable"),
1022                                                          P_("View is reorderable"),
1023                                                          FALSE,
1024                                                          GTK_PARAM_READWRITE));
1025
1026   g_object_class_install_property (o_class,
1027                                    PROP_RULES_HINT,
1028                                    g_param_spec_boolean ("rules-hint",
1029                                                          P_("Rules Hint"),
1030                                                          P_("Set a hint to the theme engine to draw rows in alternating colors"),
1031                                                          FALSE,
1032                                                          GTK_PARAM_READWRITE));
1033
1034     g_object_class_install_property (o_class,
1035                                      PROP_ENABLE_SEARCH,
1036                                      g_param_spec_boolean ("enable-search",
1037                                                            P_("Enable Search"),
1038                                                            P_("View allows user to search through columns interactively"),
1039                                                            TRUE,
1040                                                            GTK_PARAM_READWRITE));
1041
1042     g_object_class_install_property (o_class,
1043                                      PROP_SEARCH_COLUMN,
1044                                      g_param_spec_int ("search-column",
1045                                                        P_("Search Column"),
1046                                                        P_("Model column to search through during interactive search"),
1047                                                        -1,
1048                                                        G_MAXINT,
1049                                                        -1,
1050                                                        GTK_PARAM_READWRITE));
1051
1052     /**
1053      * GtkTreeView:fixed-height-mode:
1054      *
1055      * Setting the ::fixed-height-mode property to %TRUE speeds up
1056      * #GtkTreeView by assuming that all rows have the same height.
1057      * Only enable this option if all rows are the same height.
1058      * Please see gtk_tree_view_set_fixed_height_mode() for more
1059      * information on this option.
1060      *
1061      * Since: 2.4
1062      **/
1063     g_object_class_install_property (o_class,
1064                                      PROP_FIXED_HEIGHT_MODE,
1065                                      g_param_spec_boolean ("fixed-height-mode",
1066                                                            P_("Fixed Height Mode"),
1067                                                            P_("Speeds up GtkTreeView by assuming that all rows have the same height"),
1068                                                            FALSE,
1069                                                            GTK_PARAM_READWRITE));
1070
1071     /**
1072      * GtkTreeView:hover-selection:
1073      *
1074      * Enables or disables the hover selection mode of @tree_view.
1075      * Hover selection makes the selected row follow the pointer.
1076      * Currently, this works only for the selection modes
1077      * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
1078      *
1079      * This mode is primarily intended for treeviews in popups, e.g.
1080      * in #GtkComboBox or #GtkEntryCompletion.
1081      *
1082      * Since: 2.6
1083      */
1084     g_object_class_install_property (o_class,
1085                                      PROP_HOVER_SELECTION,
1086                                      g_param_spec_boolean ("hover-selection",
1087                                                            P_("Hover Selection"),
1088                                                            P_("Whether the selection should follow the pointer"),
1089                                                            FALSE,
1090                                                            GTK_PARAM_READWRITE));
1091
1092     /**
1093      * GtkTreeView:hover-expand:
1094      *
1095      * Enables or disables the hover expansion mode of @tree_view.
1096      * Hover expansion makes rows expand or collapse if the pointer moves
1097      * over them.
1098      *
1099      * This mode is primarily intended for treeviews in popups, e.g.
1100      * in #GtkComboBox or #GtkEntryCompletion.
1101      *
1102      * Since: 2.6
1103      */
1104     g_object_class_install_property (o_class,
1105                                      PROP_HOVER_EXPAND,
1106                                      g_param_spec_boolean ("hover-expand",
1107                                                            P_("Hover Expand"),
1108                                                            P_("Whether rows should be expanded/collapsed when the pointer moves over them"),
1109                                                            FALSE,
1110                                                            GTK_PARAM_READWRITE));
1111
1112     /**
1113      * GtkTreeView:show-expanders:
1114      *
1115      * %TRUE if the view has expanders.
1116      *
1117      * Since: 2.12
1118      */
1119     g_object_class_install_property (o_class,
1120                                      PROP_SHOW_EXPANDERS,
1121                                      g_param_spec_boolean ("show-expanders",
1122                                                            P_("Show Expanders"),
1123                                                            P_("View has expanders"),
1124                                                            TRUE,
1125                                                            GTK_PARAM_READWRITE));
1126
1127     /**
1128      * GtkTreeView:level-indentation:
1129      *
1130      * Extra indentation for each level.
1131      *
1132      * Since: 2.12
1133      */
1134     g_object_class_install_property (o_class,
1135                                      PROP_LEVEL_INDENTATION,
1136                                      g_param_spec_int ("level-indentation",
1137                                                        P_("Level Indentation"),
1138                                                        P_("Extra indentation for each level"),
1139                                                        0,
1140                                                        G_MAXINT,
1141                                                        0,
1142                                                        GTK_PARAM_READWRITE));
1143
1144     g_object_class_install_property (o_class,
1145                                      PROP_RUBBER_BANDING,
1146                                      g_param_spec_boolean ("rubber-banding",
1147                                                            P_("Rubber Banding"),
1148                                                            P_("Whether to enable selection of multiple items by dragging the mouse pointer"),
1149                                                            FALSE,
1150                                                            GTK_PARAM_READWRITE));
1151
1152     g_object_class_install_property (o_class,
1153                                      PROP_ENABLE_GRID_LINES,
1154                                      g_param_spec_enum ("enable-grid-lines",
1155                                                         P_("Enable Grid Lines"),
1156                                                         P_("Whether grid lines should be drawn in the tree view"),
1157                                                         GTK_TYPE_TREE_VIEW_GRID_LINES,
1158                                                         GTK_TREE_VIEW_GRID_LINES_NONE,
1159                                                         GTK_PARAM_READWRITE));
1160
1161     g_object_class_install_property (o_class,
1162                                      PROP_ENABLE_TREE_LINES,
1163                                      g_param_spec_boolean ("enable-tree-lines",
1164                                                            P_("Enable Tree Lines"),
1165                                                            P_("Whether tree lines should be drawn in the tree view"),
1166                                                            FALSE,
1167                                                            GTK_PARAM_READWRITE));
1168
1169     g_object_class_install_property (o_class,
1170                                      PROP_TOOLTIP_COLUMN,
1171                                      g_param_spec_int ("tooltip-column",
1172                                                        P_("Tooltip Column"),
1173                                                        P_("The column in the model containing the tooltip texts for the rows"),
1174                                                        -1,
1175                                                        G_MAXINT,
1176                                                        -1,
1177                                                        GTK_PARAM_READWRITE));
1178
1179   /**
1180    * GtkTreeView:activate-on-single-click:
1181    *
1182    * The activate-on-single-click property specifies whether the "row-activated" signal
1183    * will be emitted after a single click.
1184    *
1185    * Since: 3.8
1186    */
1187   g_object_class_install_property (o_class,
1188                                    PROP_ACTIVATE_ON_SINGLE_CLICK,
1189                                    g_param_spec_boolean ("activate-on-single-click",
1190                                                          P_("Activate on Single Click"),
1191                                                          P_("Activate row on a single click"),
1192                                                          FALSE,
1193                                                          GTK_PARAM_READWRITE));
1194
1195   /* Style properties */
1196 #define _TREE_VIEW_EXPANDER_SIZE 14
1197 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
1198 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
1199
1200   gtk_widget_class_install_style_property (widget_class,
1201                                            g_param_spec_int ("expander-size",
1202                                                              P_("Expander Size"),
1203                                                              P_("Size of the expander arrow"),
1204                                                              0,
1205                                                              G_MAXINT,
1206                                                              _TREE_VIEW_EXPANDER_SIZE,
1207                                                              GTK_PARAM_READABLE));
1208
1209   gtk_widget_class_install_style_property (widget_class,
1210                                            g_param_spec_int ("vertical-separator",
1211                                                              P_("Vertical Separator Width"),
1212                                                              P_("Vertical space between cells.  Must be an even number"),
1213                                                              0,
1214                                                              G_MAXINT,
1215                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
1216                                                              GTK_PARAM_READABLE));
1217
1218   gtk_widget_class_install_style_property (widget_class,
1219                                            g_param_spec_int ("horizontal-separator",
1220                                                              P_("Horizontal Separator Width"),
1221                                                              P_("Horizontal space between cells.  Must be an even number"),
1222                                                              0,
1223                                                              G_MAXINT,
1224                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
1225                                                              GTK_PARAM_READABLE));
1226
1227   gtk_widget_class_install_style_property (widget_class,
1228                                            g_param_spec_boolean ("allow-rules",
1229                                                                  P_("Allow Rules"),
1230                                                                  P_("Allow drawing of alternating color rows"),
1231                                                                  TRUE,
1232                                                                  GTK_PARAM_READABLE));
1233
1234   gtk_widget_class_install_style_property (widget_class,
1235                                            g_param_spec_boolean ("indent-expanders",
1236                                                                  P_("Indent Expanders"),
1237                                                                  P_("Make the expanders indented"),
1238                                                                  TRUE,
1239                                                                  GTK_PARAM_READABLE));
1240
1241   gtk_widget_class_install_style_property (widget_class,
1242                                            g_param_spec_boxed ("even-row-color",
1243                                                                P_("Even Row Color"),
1244                                                                P_("Color to use for even rows"),
1245                                                                GDK_TYPE_COLOR,
1246                                                                GTK_PARAM_READABLE));
1247
1248   gtk_widget_class_install_style_property (widget_class,
1249                                            g_param_spec_boxed ("odd-row-color",
1250                                                                P_("Odd Row Color"),
1251                                                                P_("Color to use for odd rows"),
1252                                                                GDK_TYPE_COLOR,
1253                                                                GTK_PARAM_READABLE));
1254
1255   gtk_widget_class_install_style_property (widget_class,
1256                                            g_param_spec_int ("grid-line-width",
1257                                                              P_("Grid line width"),
1258                                                              P_("Width, in pixels, of the tree view grid lines"),
1259                                                              0, G_MAXINT, 1,
1260                                                              GTK_PARAM_READABLE));
1261
1262   gtk_widget_class_install_style_property (widget_class,
1263                                            g_param_spec_int ("tree-line-width",
1264                                                              P_("Tree line width"),
1265                                                              P_("Width, in pixels, of the tree view lines"),
1266                                                              0, G_MAXINT, 1,
1267                                                              GTK_PARAM_READABLE));
1268
1269   gtk_widget_class_install_style_property (widget_class,
1270                                            g_param_spec_string ("grid-line-pattern",
1271                                                                 P_("Grid line pattern"),
1272                                                                 P_("Dash pattern used to draw the tree view grid lines"),
1273                                                                 "\1\1",
1274                                                                 GTK_PARAM_READABLE));
1275
1276   gtk_widget_class_install_style_property (widget_class,
1277                                            g_param_spec_string ("tree-line-pattern",
1278                                                                 P_("Tree line pattern"),
1279                                                                 P_("Dash pattern used to draw the tree view lines"),
1280                                                                 "\1\1",
1281                                                                 GTK_PARAM_READABLE));
1282
1283   /* Signals */
1284   /**
1285    * GtkTreeView::row-activated:
1286    * @tree_view: the object on which the signal is emitted
1287    * @path: the #GtkTreePath for the activated row
1288    * @column: the #GtkTreeViewColumn in which the activation occurred
1289    *
1290    * The "row-activated" signal is emitted when the method
1291    * gtk_tree_view_row_activated() is called, when the user double
1292    * clicks a treeview row with the "activate-on-single-click"
1293    * property set to %FALSE, or when the user single clicks a row when
1294    * the "activate-on-single-click" property set to %TRUE. It is also
1295    * emitted when a non-editable row is selected and one of the keys:
1296    * Space, Shift+Space, Return or Enter is pressed.
1297    *
1298    * For selection handling refer to the <link linkend="TreeWidget">tree
1299    * widget conceptual overview</link> as well as #GtkTreeSelection.
1300    */
1301   tree_view_signals[ROW_ACTIVATED] =
1302     g_signal_new (I_("row-activated"),
1303                   G_TYPE_FROM_CLASS (o_class),
1304                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1305                   G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
1306                   NULL, NULL,
1307                   _gtk_marshal_VOID__BOXED_OBJECT,
1308                   G_TYPE_NONE, 2,
1309                   GTK_TYPE_TREE_PATH,
1310                   GTK_TYPE_TREE_VIEW_COLUMN);
1311
1312   /**
1313    * GtkTreeView::test-expand-row:
1314    * @tree_view: the object on which the signal is emitted
1315    * @iter: the tree iter of the row to expand
1316    * @path: a tree path that points to the row
1317    *
1318    * The given row is about to be expanded (show its children nodes). Use this
1319    * signal if you need to control the expandability of individual rows.
1320    *
1321    * Returns: %FALSE to allow expansion, %TRUE to reject
1322    */
1323   tree_view_signals[TEST_EXPAND_ROW] =
1324     g_signal_new (I_("test-expand-row"),
1325                   G_TYPE_FROM_CLASS (o_class),
1326                   G_SIGNAL_RUN_LAST,
1327                   G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
1328                   _gtk_boolean_handled_accumulator, NULL,
1329                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1330                   G_TYPE_BOOLEAN, 2,
1331                   GTK_TYPE_TREE_ITER,
1332                   GTK_TYPE_TREE_PATH);
1333
1334   /**
1335    * GtkTreeView::test-collapse-row:
1336    * @tree_view: the object on which the signal is emitted
1337    * @iter: the tree iter of the row to collapse
1338    * @path: a tree path that points to the row
1339    *
1340    * The given row is about to be collapsed (hide its children nodes). Use this
1341    * signal if you need to control the collapsibility of individual rows.
1342    *
1343    * Returns: %FALSE to allow collapsing, %TRUE to reject
1344    */
1345   tree_view_signals[TEST_COLLAPSE_ROW] =
1346     g_signal_new (I_("test-collapse-row"),
1347                   G_TYPE_FROM_CLASS (o_class),
1348                   G_SIGNAL_RUN_LAST,
1349                   G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
1350                   _gtk_boolean_handled_accumulator, NULL,
1351                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
1352                   G_TYPE_BOOLEAN, 2,
1353                   GTK_TYPE_TREE_ITER,
1354                   GTK_TYPE_TREE_PATH);
1355
1356   /**
1357    * GtkTreeView::row-expanded:
1358    * @tree_view: the object on which the signal is emitted
1359    * @iter: the tree iter of the expanded row
1360    * @path: a tree path that points to the row
1361    *
1362    * The given row has been expanded (child nodes are shown).
1363    */
1364   tree_view_signals[ROW_EXPANDED] =
1365     g_signal_new (I_("row-expanded"),
1366                   G_TYPE_FROM_CLASS (o_class),
1367                   G_SIGNAL_RUN_LAST,
1368                   G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
1369                   NULL, NULL,
1370                   _gtk_marshal_VOID__BOXED_BOXED,
1371                   G_TYPE_NONE, 2,
1372                   GTK_TYPE_TREE_ITER,
1373                   GTK_TYPE_TREE_PATH);
1374
1375   /**
1376    * GtkTreeView::row-collapsed:
1377    * @tree_view: the object on which the signal is emitted
1378    * @iter: the tree iter of the collapsed row
1379    * @path: a tree path that points to the row
1380    *
1381    * The given row has been collapsed (child nodes are hidden).
1382    */
1383   tree_view_signals[ROW_COLLAPSED] =
1384     g_signal_new (I_("row-collapsed"),
1385                   G_TYPE_FROM_CLASS (o_class),
1386                   G_SIGNAL_RUN_LAST,
1387                   G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
1388                   NULL, NULL,
1389                   _gtk_marshal_VOID__BOXED_BOXED,
1390                   G_TYPE_NONE, 2,
1391                   GTK_TYPE_TREE_ITER,
1392                   GTK_TYPE_TREE_PATH);
1393
1394   /**
1395    * GtkTreeView::columns-changed:
1396    * @tree_view: the object on which the signal is emitted
1397    *
1398    * The number of columns of the treeview has changed.
1399    */
1400   tree_view_signals[COLUMNS_CHANGED] =
1401     g_signal_new (I_("columns-changed"),
1402                   G_TYPE_FROM_CLASS (o_class),
1403                   G_SIGNAL_RUN_LAST,
1404                   G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
1405                   NULL, NULL,
1406                   _gtk_marshal_VOID__VOID,
1407                   G_TYPE_NONE, 0);
1408
1409   /**
1410    * GtkTreeView::cursor-changed:
1411    * @tree_view: the object on which the signal is emitted
1412    *
1413    * The position of the cursor (focused cell) has changed.
1414    */
1415   tree_view_signals[CURSOR_CHANGED] =
1416     g_signal_new (I_("cursor-changed"),
1417                   G_TYPE_FROM_CLASS (o_class),
1418                   G_SIGNAL_RUN_LAST,
1419                   G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
1420                   NULL, NULL,
1421                   _gtk_marshal_VOID__VOID,
1422                   G_TYPE_NONE, 0);
1423
1424   tree_view_signals[MOVE_CURSOR] =
1425     g_signal_new (I_("move-cursor"),
1426                   G_TYPE_FROM_CLASS (o_class),
1427                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1428                   G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
1429                   NULL, NULL,
1430                   _gtk_marshal_BOOLEAN__ENUM_INT,
1431                   G_TYPE_BOOLEAN, 2,
1432                   GTK_TYPE_MOVEMENT_STEP,
1433                   G_TYPE_INT);
1434
1435   tree_view_signals[SELECT_ALL] =
1436     g_signal_new (I_("select-all"),
1437                   G_TYPE_FROM_CLASS (o_class),
1438                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1439                   G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
1440                   NULL, NULL,
1441                   _gtk_marshal_BOOLEAN__VOID,
1442                   G_TYPE_BOOLEAN, 0);
1443
1444   tree_view_signals[UNSELECT_ALL] =
1445     g_signal_new (I_("unselect-all"),
1446                   G_TYPE_FROM_CLASS (o_class),
1447                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1448                   G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
1449                   NULL, NULL,
1450                   _gtk_marshal_BOOLEAN__VOID,
1451                   G_TYPE_BOOLEAN, 0);
1452
1453   tree_view_signals[SELECT_CURSOR_ROW] =
1454     g_signal_new (I_("select-cursor-row"),
1455                   G_TYPE_FROM_CLASS (o_class),
1456                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1457                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
1458                   NULL, NULL,
1459                   _gtk_marshal_BOOLEAN__BOOLEAN,
1460                   G_TYPE_BOOLEAN, 1,
1461                   G_TYPE_BOOLEAN);
1462
1463   tree_view_signals[TOGGLE_CURSOR_ROW] =
1464     g_signal_new (I_("toggle-cursor-row"),
1465                   G_TYPE_FROM_CLASS (o_class),
1466                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1467                   G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
1468                   NULL, NULL,
1469                   _gtk_marshal_BOOLEAN__VOID,
1470                   G_TYPE_BOOLEAN, 0);
1471
1472   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
1473     g_signal_new (I_("expand-collapse-cursor-row"),
1474                   G_TYPE_FROM_CLASS (o_class),
1475                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1476                   G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
1477                   NULL, NULL,
1478                   _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
1479                   G_TYPE_BOOLEAN, 3,
1480                   G_TYPE_BOOLEAN,
1481                   G_TYPE_BOOLEAN,
1482                   G_TYPE_BOOLEAN);
1483
1484   tree_view_signals[SELECT_CURSOR_PARENT] =
1485     g_signal_new (I_("select-cursor-parent"),
1486                   G_TYPE_FROM_CLASS (o_class),
1487                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1488                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
1489                   NULL, NULL,
1490                   _gtk_marshal_BOOLEAN__VOID,
1491                   G_TYPE_BOOLEAN, 0);
1492
1493   tree_view_signals[START_INTERACTIVE_SEARCH] =
1494     g_signal_new (I_("start-interactive-search"),
1495                   G_TYPE_FROM_CLASS (o_class),
1496                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1497                   G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
1498                   NULL, NULL,
1499                   _gtk_marshal_BOOLEAN__VOID,
1500                   G_TYPE_BOOLEAN, 0);
1501
1502   /* Key bindings */
1503   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Up, 0, TRUE,
1504                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1505   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Up, 0, TRUE,
1506                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1507
1508   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Down, 0, TRUE,
1509                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1510   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Down, 0, TRUE,
1511                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1512
1513   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_p, GDK_CONTROL_MASK, FALSE,
1514                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1515
1516   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_n, GDK_CONTROL_MASK, FALSE,
1517                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1518
1519   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Home, 0, TRUE,
1520                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1521   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Home, 0, TRUE,
1522                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1523
1524   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_End, 0, TRUE,
1525                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1526   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_End, 0, TRUE,
1527                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1528
1529   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Up, 0, TRUE,
1530                                   GTK_MOVEMENT_PAGES, -1);
1531   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0, TRUE,
1532                                   GTK_MOVEMENT_PAGES, -1);
1533
1534   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Down, 0, TRUE,
1535                                   GTK_MOVEMENT_PAGES, 1);
1536   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0, TRUE,
1537                                   GTK_MOVEMENT_PAGES, 1);
1538
1539
1540   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 0, "move-cursor", 2,
1541                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1542                                 G_TYPE_INT, 1);
1543
1544   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 0, "move-cursor", 2,
1545                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1546                                 G_TYPE_INT, -1);
1547
1548   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, 0, "move-cursor", 2,
1549                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1550                                 G_TYPE_INT, 1);
1551
1552   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, 0, "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_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_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_KP_Right, GDK_CONTROL_MASK,
1567                                 "move-cursor", 2,
1568                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1569                                 G_TYPE_INT, 1);
1570
1571   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
1572                                 "move-cursor", 2,
1573                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1574                                 G_TYPE_INT, -1);
1575
1576   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1577   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1578
1579   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK, "select-all", 0);
1580   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK, "select-all", 0);
1581
1582   gtk_binding_entry_add_signal (binding_set, GDK_KEY_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1583   gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1584
1585   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1586                                 G_TYPE_BOOLEAN, TRUE);
1587   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1588                                 G_TYPE_BOOLEAN, TRUE);
1589
1590   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0, "select-cursor-row", 1,
1591                                 G_TYPE_BOOLEAN, TRUE);
1592   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0, "select-cursor-row", 1,
1593                                 G_TYPE_BOOLEAN, TRUE);
1594   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0, "select-cursor-row", 1,
1595                                 G_TYPE_BOOLEAN, TRUE);
1596   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0, "select-cursor-row", 1,
1597                                 G_TYPE_BOOLEAN, TRUE);
1598   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0, "select-cursor-row", 1,
1599                                 G_TYPE_BOOLEAN, TRUE);
1600
1601   /* expand and collapse rows */
1602   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, 0, "expand-collapse-cursor-row", 3,
1603                                 G_TYPE_BOOLEAN, TRUE,
1604                                 G_TYPE_BOOLEAN, TRUE,
1605                                 G_TYPE_BOOLEAN, FALSE);
1606
1607   gtk_binding_entry_add_signal (binding_set, GDK_KEY_asterisk, 0,
1608                                 "expand-collapse-cursor-row", 3,
1609                                 G_TYPE_BOOLEAN, TRUE,
1610                                 G_TYPE_BOOLEAN, TRUE,
1611                                 G_TYPE_BOOLEAN, TRUE);
1612   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Multiply, 0,
1613                                 "expand-collapse-cursor-row", 3,
1614                                 G_TYPE_BOOLEAN, TRUE,
1615                                 G_TYPE_BOOLEAN, TRUE,
1616                                 G_TYPE_BOOLEAN, TRUE);
1617
1618   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, 0,
1619                                 "expand-collapse-cursor-row", 3,
1620                                 G_TYPE_BOOLEAN, TRUE,
1621                                 G_TYPE_BOOLEAN, FALSE,
1622                                 G_TYPE_BOOLEAN, FALSE);
1623   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Divide, 0,
1624                                 "expand-collapse-cursor-row", 3,
1625                                 G_TYPE_BOOLEAN, TRUE,
1626                                 G_TYPE_BOOLEAN, FALSE,
1627                                 G_TYPE_BOOLEAN, FALSE);
1628
1629   /* Not doable on US keyboards */
1630   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1631                                 G_TYPE_BOOLEAN, TRUE,
1632                                 G_TYPE_BOOLEAN, TRUE,
1633                                 G_TYPE_BOOLEAN, TRUE);
1634   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, 0, "expand-collapse-cursor-row", 3,
1635                                 G_TYPE_BOOLEAN, TRUE,
1636                                 G_TYPE_BOOLEAN, TRUE,
1637                                 G_TYPE_BOOLEAN, FALSE);
1638   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1639                                 G_TYPE_BOOLEAN, TRUE,
1640                                 G_TYPE_BOOLEAN, TRUE,
1641                                 G_TYPE_BOOLEAN, TRUE);
1642   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1643                                 G_TYPE_BOOLEAN, TRUE,
1644                                 G_TYPE_BOOLEAN, TRUE,
1645                                 G_TYPE_BOOLEAN, TRUE);
1646   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_SHIFT_MASK,
1647                                 "expand-collapse-cursor-row", 3,
1648                                 G_TYPE_BOOLEAN, FALSE,
1649                                 G_TYPE_BOOLEAN, TRUE,
1650                                 G_TYPE_BOOLEAN, TRUE);
1651   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_SHIFT_MASK,
1652                                 "expand-collapse-cursor-row", 3,
1653                                 G_TYPE_BOOLEAN, FALSE,
1654                                 G_TYPE_BOOLEAN, TRUE,
1655                                 G_TYPE_BOOLEAN, TRUE);
1656   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right,
1657                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1658                                 "expand-collapse-cursor-row", 3,
1659                                 G_TYPE_BOOLEAN, FALSE,
1660                                 G_TYPE_BOOLEAN, TRUE,
1661                                 G_TYPE_BOOLEAN, TRUE);
1662   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right,
1663                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1664                                 "expand-collapse-cursor-row", 3,
1665                                 G_TYPE_BOOLEAN, FALSE,
1666                                 G_TYPE_BOOLEAN, TRUE,
1667                                 G_TYPE_BOOLEAN, TRUE);
1668
1669   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, 0, "expand-collapse-cursor-row", 3,
1670                                 G_TYPE_BOOLEAN, TRUE,
1671                                 G_TYPE_BOOLEAN, FALSE,
1672                                 G_TYPE_BOOLEAN, FALSE);
1673   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1674                                 G_TYPE_BOOLEAN, TRUE,
1675                                 G_TYPE_BOOLEAN, FALSE,
1676                                 G_TYPE_BOOLEAN, TRUE);
1677   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, 0, "expand-collapse-cursor-row", 3,
1678                                 G_TYPE_BOOLEAN, TRUE,
1679                                 G_TYPE_BOOLEAN, FALSE,
1680                                 G_TYPE_BOOLEAN, FALSE);
1681   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1682                                 G_TYPE_BOOLEAN, TRUE,
1683                                 G_TYPE_BOOLEAN, FALSE,
1684                                 G_TYPE_BOOLEAN, TRUE);
1685   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_SHIFT_MASK,
1686                                 "expand-collapse-cursor-row", 3,
1687                                 G_TYPE_BOOLEAN, FALSE,
1688                                 G_TYPE_BOOLEAN, FALSE,
1689                                 G_TYPE_BOOLEAN, TRUE);
1690   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_SHIFT_MASK,
1691                                 "expand-collapse-cursor-row", 3,
1692                                 G_TYPE_BOOLEAN, FALSE,
1693                                 G_TYPE_BOOLEAN, FALSE,
1694                                 G_TYPE_BOOLEAN, TRUE);
1695   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left,
1696                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1697                                 "expand-collapse-cursor-row", 3,
1698                                 G_TYPE_BOOLEAN, FALSE,
1699                                 G_TYPE_BOOLEAN, FALSE,
1700                                 G_TYPE_BOOLEAN, TRUE);
1701   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left,
1702                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1703                                 "expand-collapse-cursor-row", 3,
1704                                 G_TYPE_BOOLEAN, FALSE,
1705                                 G_TYPE_BOOLEAN, FALSE,
1706                                 G_TYPE_BOOLEAN, TRUE);
1707
1708   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, 0, "select-cursor-parent", 0);
1709   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1710
1711   gtk_binding_entry_add_signal (binding_set, GDK_KEY_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1712
1713   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1714
1715   g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
1716
1717   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TREE_VIEW_ACCESSIBLE);
1718 }
1719
1720 static void
1721 gtk_tree_view_init (GtkTreeView *tree_view)
1722 {
1723   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
1724
1725   gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
1726   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1727
1728   tree_view->priv->show_expanders = TRUE;
1729   tree_view->priv->draw_keyfocus = TRUE;
1730   tree_view->priv->headers_visible = TRUE;
1731   tree_view->priv->activate_on_single_click = FALSE;
1732
1733   /* We need some padding */
1734   tree_view->priv->dy = 0;
1735   tree_view->priv->cursor_offset = 0;
1736   tree_view->priv->n_columns = 0;
1737   tree_view->priv->header_height = 1;
1738   tree_view->priv->x_drag = 0;
1739   tree_view->priv->drag_pos = -1;
1740   tree_view->priv->minimum_width = 0;
1741   tree_view->priv->natural_width = 0;
1742   tree_view->priv->n_expand_columns = 0;
1743   tree_view->priv->header_has_focus = FALSE;
1744   tree_view->priv->pressed_button = -1;
1745   tree_view->priv->press_start_x = -1;
1746   tree_view->priv->press_start_y = -1;
1747   tree_view->priv->reorderable = FALSE;
1748   tree_view->priv->presize_handler_timer = 0;
1749   tree_view->priv->scroll_sync_timer = 0;
1750   tree_view->priv->fixed_height = -1;
1751   tree_view->priv->fixed_height_mode = FALSE;
1752   tree_view->priv->fixed_height_check = 0;
1753   tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
1754   tree_view->priv->enable_search = TRUE;
1755   tree_view->priv->search_column = -1;
1756   tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
1757   tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
1758   tree_view->priv->search_custom_entry_set = FALSE;
1759   tree_view->priv->typeselect_flush_timeout = 0;
1760   tree_view->priv->init_hadjust_value = TRUE;
1761   tree_view->priv->width = 0;
1762
1763   tree_view->priv->hover_selection = FALSE;
1764   tree_view->priv->hover_expand = FALSE;
1765
1766   tree_view->priv->level_indentation = 0;
1767
1768   tree_view->priv->rubber_banding_enable = FALSE;
1769
1770   tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
1771   tree_view->priv->tree_lines_enabled = FALSE;
1772
1773   tree_view->priv->tooltip_column = -1;
1774
1775   tree_view->priv->last_button_x = -1;
1776   tree_view->priv->last_button_y = -1;
1777
1778   tree_view->priv->event_last_x = -10000;
1779   tree_view->priv->event_last_y = -10000;
1780
1781   gtk_tree_view_do_set_vadjustment (tree_view, NULL);
1782   gtk_tree_view_do_set_hadjustment (tree_view, NULL);
1783
1784   gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (tree_view)),
1785                                GTK_STYLE_CLASS_VIEW);
1786 }
1787
1788 \f
1789
1790 /* GObject Methods
1791  */
1792
1793 static void
1794 gtk_tree_view_set_property (GObject         *object,
1795                             guint            prop_id,
1796                             const GValue    *value,
1797                             GParamSpec      *pspec)
1798 {
1799   GtkTreeView *tree_view;
1800
1801   tree_view = GTK_TREE_VIEW (object);
1802
1803   switch (prop_id)
1804     {
1805     case PROP_MODEL:
1806       gtk_tree_view_set_model (tree_view, g_value_get_object (value));
1807       break;
1808     case PROP_HADJUSTMENT:
1809       gtk_tree_view_do_set_hadjustment (tree_view, g_value_get_object (value));
1810       break;
1811     case PROP_VADJUSTMENT:
1812       gtk_tree_view_do_set_vadjustment (tree_view, g_value_get_object (value));
1813       break;
1814     case PROP_HSCROLL_POLICY:
1815       tree_view->priv->hscroll_policy = g_value_get_enum (value);
1816       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1817       break;
1818     case PROP_VSCROLL_POLICY:
1819       tree_view->priv->vscroll_policy = g_value_get_enum (value);
1820       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1821       break;
1822     case PROP_HEADERS_VISIBLE:
1823       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1824       break;
1825     case PROP_HEADERS_CLICKABLE:
1826       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1827       break;
1828     case PROP_EXPANDER_COLUMN:
1829       gtk_tree_view_set_expander_column (tree_view, g_value_get_object (value));
1830       break;
1831     case PROP_REORDERABLE:
1832       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
1833       break;
1834     case PROP_RULES_HINT:
1835       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1836       break;
1837     case PROP_ENABLE_SEARCH:
1838       gtk_tree_view_set_enable_search (tree_view, g_value_get_boolean (value));
1839       break;
1840     case PROP_SEARCH_COLUMN:
1841       gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
1842       break;
1843     case PROP_FIXED_HEIGHT_MODE:
1844       gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
1845       break;
1846     case PROP_HOVER_SELECTION:
1847       tree_view->priv->hover_selection = g_value_get_boolean (value);
1848       break;
1849     case PROP_HOVER_EXPAND:
1850       tree_view->priv->hover_expand = g_value_get_boolean (value);
1851       break;
1852     case PROP_SHOW_EXPANDERS:
1853       gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
1854       break;
1855     case PROP_LEVEL_INDENTATION:
1856       tree_view->priv->level_indentation = g_value_get_int (value);
1857       break;
1858     case PROP_RUBBER_BANDING:
1859       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1860       break;
1861     case PROP_ENABLE_GRID_LINES:
1862       gtk_tree_view_set_grid_lines (tree_view, g_value_get_enum (value));
1863       break;
1864     case PROP_ENABLE_TREE_LINES:
1865       gtk_tree_view_set_enable_tree_lines (tree_view, g_value_get_boolean (value));
1866       break;
1867     case PROP_TOOLTIP_COLUMN:
1868       gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
1869       break;
1870     case PROP_ACTIVATE_ON_SINGLE_CLICK:
1871       gtk_tree_view_set_activate_on_single_click (tree_view, g_value_get_boolean (value));
1872       break;
1873     default:
1874       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1875       break;
1876     }
1877 }
1878
1879 static void
1880 gtk_tree_view_get_property (GObject    *object,
1881                             guint       prop_id,
1882                             GValue     *value,
1883                             GParamSpec *pspec)
1884 {
1885   GtkTreeView *tree_view;
1886
1887   tree_view = GTK_TREE_VIEW (object);
1888
1889   switch (prop_id)
1890     {
1891     case PROP_MODEL:
1892       g_value_set_object (value, tree_view->priv->model);
1893       break;
1894     case PROP_HADJUSTMENT:
1895       g_value_set_object (value, tree_view->priv->hadjustment);
1896       break;
1897     case PROP_VADJUSTMENT:
1898       g_value_set_object (value, tree_view->priv->vadjustment);
1899       break;
1900     case PROP_HSCROLL_POLICY:
1901       g_value_set_enum (value, tree_view->priv->hscroll_policy);
1902       break;
1903     case PROP_VSCROLL_POLICY:
1904       g_value_set_enum (value, tree_view->priv->vscroll_policy);
1905       break;
1906     case PROP_HEADERS_VISIBLE:
1907       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
1908       break;
1909     case PROP_HEADERS_CLICKABLE:
1910       g_value_set_boolean (value, gtk_tree_view_get_headers_clickable (tree_view));
1911       break;
1912     case PROP_EXPANDER_COLUMN:
1913       g_value_set_object (value, tree_view->priv->expander_column);
1914       break;
1915     case PROP_REORDERABLE:
1916       g_value_set_boolean (value, tree_view->priv->reorderable);
1917       break;
1918     case PROP_RULES_HINT:
1919       g_value_set_boolean (value, tree_view->priv->has_rules);
1920       break;
1921     case PROP_ENABLE_SEARCH:
1922       g_value_set_boolean (value, tree_view->priv->enable_search);
1923       break;
1924     case PROP_SEARCH_COLUMN:
1925       g_value_set_int (value, tree_view->priv->search_column);
1926       break;
1927     case PROP_FIXED_HEIGHT_MODE:
1928       g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
1929       break;
1930     case PROP_HOVER_SELECTION:
1931       g_value_set_boolean (value, tree_view->priv->hover_selection);
1932       break;
1933     case PROP_HOVER_EXPAND:
1934       g_value_set_boolean (value, tree_view->priv->hover_expand);
1935       break;
1936     case PROP_SHOW_EXPANDERS:
1937       g_value_set_boolean (value, tree_view->priv->show_expanders);
1938       break;
1939     case PROP_LEVEL_INDENTATION:
1940       g_value_set_int (value, tree_view->priv->level_indentation);
1941       break;
1942     case PROP_RUBBER_BANDING:
1943       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1944       break;
1945     case PROP_ENABLE_GRID_LINES:
1946       g_value_set_enum (value, tree_view->priv->grid_lines);
1947       break;
1948     case PROP_ENABLE_TREE_LINES:
1949       g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
1950       break;
1951     case PROP_TOOLTIP_COLUMN:
1952       g_value_set_int (value, tree_view->priv->tooltip_column);
1953       break;
1954     case PROP_ACTIVATE_ON_SINGLE_CLICK:
1955       g_value_set_boolean (value, tree_view->priv->activate_on_single_click);
1956       break;
1957     default:
1958       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1959       break;
1960     }
1961 }
1962
1963 static void
1964 gtk_tree_view_finalize (GObject *object)
1965 {
1966   G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
1967 }
1968
1969
1970 static GtkBuildableIface *parent_buildable_iface;
1971
1972 static void
1973 gtk_tree_view_buildable_init (GtkBuildableIface *iface)
1974 {
1975   parent_buildable_iface = g_type_interface_peek_parent (iface);
1976   iface->add_child = gtk_tree_view_buildable_add_child;
1977   iface->get_internal_child = gtk_tree_view_buildable_get_internal_child;
1978 }
1979
1980 static void
1981 gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
1982                                    GtkBuilder  *builder,
1983                                    GObject     *child,
1984                                    const gchar *type)
1985 {
1986   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (child));
1987 }
1988
1989 static GObject *
1990 gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
1991                                             GtkBuilder        *builder,
1992                                             const gchar       *childname)
1993 {
1994     if (strcmp (childname, "selection") == 0)
1995       return G_OBJECT (GTK_TREE_VIEW (buildable)->priv->selection);
1996
1997     return parent_buildable_iface->get_internal_child (buildable,
1998                                                        builder,
1999                                                        childname);
2000 }
2001
2002 /* GtkWidget Methods
2003  */
2004
2005 static void
2006 gtk_tree_view_free_rbtree (GtkTreeView *tree_view)
2007 {
2008   _gtk_rbtree_free (tree_view->priv->tree);
2009
2010   tree_view->priv->tree = NULL;
2011   tree_view->priv->button_pressed_node = NULL;
2012   tree_view->priv->button_pressed_tree = NULL;
2013   tree_view->priv->prelight_tree = NULL;
2014   tree_view->priv->prelight_node = NULL;
2015   tree_view->priv->expanded_collapsed_node = NULL;
2016   tree_view->priv->expanded_collapsed_tree = NULL;
2017 }
2018
2019 static void
2020 gtk_tree_view_destroy (GtkWidget *widget)
2021 {
2022   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2023   GList *list;
2024
2025   gtk_tree_view_stop_editing (tree_view, TRUE);
2026
2027   if (tree_view->priv->columns != NULL)
2028     {
2029       list = tree_view->priv->columns;
2030       while (list)
2031         {
2032           GtkTreeViewColumn *column;
2033           column = GTK_TREE_VIEW_COLUMN (list->data);
2034           list = list->next;
2035           gtk_tree_view_remove_column (tree_view, column);
2036         }
2037       tree_view->priv->columns = NULL;
2038     }
2039
2040   if (tree_view->priv->tree != NULL)
2041     {
2042       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
2043
2044       gtk_tree_view_free_rbtree (tree_view);
2045     }
2046
2047   if (tree_view->priv->selection != NULL)
2048     {
2049       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
2050       g_object_unref (tree_view->priv->selection);
2051       tree_view->priv->selection = NULL;
2052     }
2053
2054   if (tree_view->priv->scroll_to_path != NULL)
2055     {
2056       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
2057       tree_view->priv->scroll_to_path = NULL;
2058     }
2059
2060   if (tree_view->priv->drag_dest_row != NULL)
2061     {
2062       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
2063       tree_view->priv->drag_dest_row = NULL;
2064     }
2065
2066   if (tree_view->priv->top_row != NULL)
2067     {
2068       gtk_tree_row_reference_free (tree_view->priv->top_row);
2069       tree_view->priv->top_row = NULL;
2070     }
2071
2072   if (tree_view->priv->column_drop_func_data &&
2073       tree_view->priv->column_drop_func_data_destroy)
2074     {
2075       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
2076       tree_view->priv->column_drop_func_data = NULL;
2077     }
2078
2079   if (tree_view->priv->destroy_count_destroy &&
2080       tree_view->priv->destroy_count_data)
2081     {
2082       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
2083       tree_view->priv->destroy_count_data = NULL;
2084     }
2085
2086   gtk_tree_row_reference_free (tree_view->priv->anchor);
2087   tree_view->priv->anchor = NULL;
2088
2089   /* destroy interactive search dialog */
2090   if (tree_view->priv->search_window)
2091     {
2092       gtk_widget_destroy (tree_view->priv->search_window);
2093       tree_view->priv->search_window = NULL;
2094       tree_view->priv->search_entry = NULL;
2095       if (tree_view->priv->typeselect_flush_timeout)
2096         {
2097           g_source_remove (tree_view->priv->typeselect_flush_timeout);
2098           tree_view->priv->typeselect_flush_timeout = 0;
2099         }
2100     }
2101
2102   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
2103     {
2104       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
2105       tree_view->priv->search_user_data = NULL;
2106     }
2107
2108   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
2109     {
2110       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
2111       tree_view->priv->search_position_user_data = NULL;
2112     }
2113
2114   if (tree_view->priv->row_separator_destroy && tree_view->priv->row_separator_data)
2115     {
2116       tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
2117       tree_view->priv->row_separator_data = NULL;
2118     }
2119
2120   gtk_tree_view_set_model (tree_view, NULL);
2121
2122   if (tree_view->priv->hadjustment)
2123     {
2124       g_object_unref (tree_view->priv->hadjustment);
2125       tree_view->priv->hadjustment = NULL;
2126     }
2127   if (tree_view->priv->vadjustment)
2128     {
2129       g_object_unref (tree_view->priv->vadjustment);
2130       tree_view->priv->vadjustment = NULL;
2131     }
2132
2133   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->destroy (widget);
2134 }
2135
2136 /* GtkWidget::map helper */
2137 static void
2138 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
2139 {
2140   GList *list;
2141
2142   g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
2143
2144   if (tree_view->priv->headers_visible)
2145     {
2146       GtkTreeViewColumn *column;
2147       GtkWidget         *button;
2148       GdkWindow         *window;
2149
2150       for (list = tree_view->priv->columns; list; list = list->next)
2151         {
2152           column = list->data;
2153           button = gtk_tree_view_column_get_button (column);
2154
2155           if (gtk_tree_view_column_get_visible (column) && button)
2156             gtk_widget_show_now (button);
2157
2158           if (gtk_widget_get_visible (button) &&
2159               !gtk_widget_get_mapped (button))
2160             gtk_widget_map (button);
2161         }
2162       for (list = tree_view->priv->columns; list; list = list->next)
2163         {
2164           column = list->data;
2165           if (gtk_tree_view_column_get_visible (column) == FALSE)
2166             continue;
2167
2168           window = _gtk_tree_view_column_get_window (column);
2169           if (gtk_tree_view_column_get_resizable (column))
2170             {
2171               gdk_window_raise (window);
2172               gdk_window_show (window);
2173             }
2174           else
2175             gdk_window_hide (window);
2176         }
2177       gdk_window_show (tree_view->priv->header_window);
2178     }
2179 }
2180
2181 static void
2182 gtk_tree_view_map (GtkWidget *widget)
2183 {
2184   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2185   GList *tmp_list;
2186
2187   gtk_widget_set_mapped (widget, TRUE);
2188
2189   tmp_list = tree_view->priv->children;
2190   while (tmp_list)
2191     {
2192       GtkTreeViewChild *child = tmp_list->data;
2193       tmp_list = tmp_list->next;
2194
2195       if (gtk_widget_get_visible (child->widget))
2196         {
2197           if (!gtk_widget_get_mapped (child->widget))
2198             gtk_widget_map (child->widget);
2199         }
2200     }
2201   gdk_window_show (tree_view->priv->bin_window);
2202
2203   gtk_tree_view_map_buttons (tree_view);
2204
2205   gdk_window_show (gtk_widget_get_window (widget));
2206 }
2207
2208 static void
2209 gtk_tree_view_ensure_background (GtkTreeView *tree_view)
2210 {
2211   GtkStyleContext *context;
2212
2213   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
2214
2215   gtk_style_context_set_background (context, tree_view->priv->bin_window);
2216   gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view)));
2217   gtk_style_context_set_background (context, tree_view->priv->header_window);
2218 }
2219
2220 static void
2221 gtk_tree_view_realize (GtkWidget *widget)
2222 {
2223   GtkAllocation allocation;
2224   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2225   GdkWindow *window;
2226   GdkWindowAttr attributes;
2227   GList *tmp_list;
2228   gint attributes_mask;
2229
2230   gtk_widget_set_realized (widget, TRUE);
2231
2232   gtk_widget_get_allocation (widget, &allocation);
2233
2234   /* Make the main, clipping window */
2235   attributes.window_type = GDK_WINDOW_CHILD;
2236   attributes.x = allocation.x;
2237   attributes.y = allocation.y;
2238   attributes.width = allocation.width;
2239   attributes.height = allocation.height;
2240   attributes.wclass = GDK_INPUT_OUTPUT;
2241   attributes.visual = gtk_widget_get_visual (widget);
2242   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
2243
2244   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
2245
2246   window = gdk_window_new (gtk_widget_get_parent_window (widget),
2247                            &attributes, attributes_mask);
2248   gtk_widget_set_window (widget, window);
2249   gtk_widget_register_window (widget, window);
2250
2251   gtk_widget_get_allocation (widget, &allocation);
2252
2253   /* Make the window for the tree */
2254   attributes.x = 0;
2255   attributes.y = gtk_tree_view_get_effective_header_height (tree_view);
2256   attributes.width = MAX (tree_view->priv->width, allocation.width);
2257   attributes.height = allocation.height;
2258   attributes.event_mask = (GDK_EXPOSURE_MASK |
2259                            GDK_SCROLL_MASK |
2260                            GDK_SMOOTH_SCROLL_MASK |
2261                            GDK_POINTER_MOTION_MASK |
2262                            GDK_ENTER_NOTIFY_MASK |
2263                            GDK_LEAVE_NOTIFY_MASK |
2264                            GDK_BUTTON_PRESS_MASK |
2265                            GDK_BUTTON_RELEASE_MASK |
2266                            gtk_widget_get_events (widget));
2267
2268   tree_view->priv->bin_window = gdk_window_new (window,
2269                                                 &attributes, attributes_mask);
2270   gtk_widget_register_window (widget, tree_view->priv->bin_window);
2271
2272   gtk_widget_get_allocation (widget, &allocation);
2273
2274   /* Make the column header window */
2275   attributes.x = 0;
2276   attributes.y = 0;
2277   attributes.width = MAX (tree_view->priv->width, allocation.width);
2278   attributes.height = tree_view->priv->header_height;
2279   attributes.event_mask = (GDK_EXPOSURE_MASK |
2280                            GDK_SCROLL_MASK |
2281                            GDK_ENTER_NOTIFY_MASK |
2282                            GDK_LEAVE_NOTIFY_MASK |
2283                            GDK_BUTTON_PRESS_MASK |
2284                            GDK_BUTTON_RELEASE_MASK |
2285                            GDK_KEY_PRESS_MASK |
2286                            GDK_KEY_RELEASE_MASK |
2287                            gtk_widget_get_events (widget));
2288
2289   tree_view->priv->header_window = gdk_window_new (window,
2290                                                    &attributes, attributes_mask);
2291   gtk_widget_register_window (widget, tree_view->priv->header_window);
2292
2293   gtk_tree_view_ensure_background (tree_view);
2294
2295   tmp_list = tree_view->priv->children;
2296   while (tmp_list)
2297     {
2298       GtkTreeViewChild *child = tmp_list->data;
2299       tmp_list = tmp_list->next;
2300
2301       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
2302     }
2303
2304   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2305     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
2306
2307   /* Need to call those here, since they create GCs */
2308   gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
2309   gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
2310
2311   install_presize_handler (tree_view);
2312 }
2313
2314 static void
2315 gtk_tree_view_unrealize (GtkWidget *widget)
2316 {
2317   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2318   GtkTreeViewPrivate *priv = tree_view->priv;
2319   GList *list;
2320
2321   if (priv->scroll_timeout != 0)
2322     {
2323       g_source_remove (priv->scroll_timeout);
2324       priv->scroll_timeout = 0;
2325     }
2326
2327   if (priv->auto_expand_timeout != 0)
2328     {
2329       g_source_remove (priv->auto_expand_timeout);
2330       priv->auto_expand_timeout = 0;
2331     }
2332
2333   if (priv->open_dest_timeout != 0)
2334     {
2335       g_source_remove (priv->open_dest_timeout);
2336       priv->open_dest_timeout = 0;
2337     }
2338
2339   if (priv->presize_handler_timer != 0)
2340     {
2341       g_source_remove (priv->presize_handler_timer);
2342       priv->presize_handler_timer = 0;
2343     }
2344
2345   if (priv->validate_rows_timer != 0)
2346     {
2347       g_source_remove (priv->validate_rows_timer);
2348       priv->validate_rows_timer = 0;
2349     }
2350
2351   if (priv->scroll_sync_timer != 0)
2352     {
2353       g_source_remove (priv->scroll_sync_timer);
2354       priv->scroll_sync_timer = 0;
2355     }
2356
2357   if (priv->typeselect_flush_timeout)
2358     {
2359       g_source_remove (priv->typeselect_flush_timeout);
2360       priv->typeselect_flush_timeout = 0;
2361     }
2362
2363   for (list = priv->columns; list; list = list->next)
2364     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
2365
2366   gtk_widget_unregister_window (widget, priv->bin_window);
2367   gdk_window_destroy (priv->bin_window);
2368   priv->bin_window = NULL;
2369
2370   gtk_widget_unregister_window (widget, priv->header_window);
2371   gdk_window_destroy (priv->header_window);
2372   priv->header_window = NULL;
2373
2374   if (priv->drag_window)
2375     {
2376       gtk_widget_unregister_window (widget, priv->drag_window);
2377       gdk_window_destroy (priv->drag_window);
2378       priv->drag_window = NULL;
2379     }
2380
2381   if (priv->drag_highlight_window)
2382     {
2383       gtk_widget_unregister_window (widget, priv->drag_highlight_window);
2384       gdk_window_destroy (priv->drag_highlight_window);
2385       priv->drag_highlight_window = NULL;
2386     }
2387
2388   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
2389 }
2390
2391 /* GtkWidget::get_preferred_height helper */
2392 static void
2393 gtk_tree_view_update_height (GtkTreeView *tree_view)
2394 {
2395   GList *list;
2396
2397   tree_view->priv->header_height = 0;
2398
2399   for (list = tree_view->priv->columns; list; list = list->next)
2400     {
2401       GtkRequisition     requisition;
2402       GtkTreeViewColumn *column = list->data;
2403       GtkWidget         *button = gtk_tree_view_column_get_button (column);
2404
2405       if (button == NULL)
2406         continue;
2407
2408       gtk_widget_get_preferred_size (button, &requisition, NULL);
2409       tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
2410     }
2411
2412   if (tree_view->priv->tree == NULL)
2413     tree_view->priv->height = 0;
2414   else
2415     tree_view->priv->height = tree_view->priv->tree->root->offset;
2416 }
2417
2418 static void
2419 gtk_tree_view_get_preferred_width (GtkWidget *widget,
2420                                    gint      *minimum,
2421                                    gint      *natural)
2422 {
2423   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2424   GList *list;
2425   GtkTreeViewColumn *column;
2426   gint column_minimum, column_natural;
2427
2428   /* we validate some rows initially just to make sure we have some size.
2429    * In practice, with a lot of static lists, this should get a good width.
2430    */
2431   do_validate_rows (tree_view, FALSE);
2432
2433   tree_view->priv->minimum_width = 0;
2434   tree_view->priv->natural_width = 0;
2435   tree_view->priv->n_expand_columns = 0;
2436
2437   /* keep this in sync with size_allocate below */
2438   for (list = tree_view->priv->columns; list; list = list->next)
2439     {
2440       column = list->data;
2441       if (!gtk_tree_view_column_get_visible (column) || column == tree_view->priv->drag_column)
2442         continue;
2443
2444       _gtk_tree_view_column_request_width (column, &column_minimum, &column_natural);
2445       tree_view->priv->minimum_width += column_minimum;
2446       tree_view->priv->natural_width += column_natural;
2447
2448       if (gtk_tree_view_column_get_expand (column))
2449         tree_view->priv->n_expand_columns++;
2450     }
2451
2452   if (minimum != NULL)
2453     *minimum = tree_view->priv->minimum_width;
2454   if (natural != NULL)
2455     *natural = tree_view->priv->natural_width;
2456 }
2457
2458 static void
2459 gtk_tree_view_get_preferred_height (GtkWidget *widget,
2460                                     gint      *minimum,
2461                                     gint      *natural)
2462 {
2463   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2464   gint height;
2465
2466   gtk_tree_view_update_height (tree_view);
2467
2468   height = tree_view->priv->height + gtk_tree_view_get_effective_header_height (tree_view);
2469
2470   if (minimum != NULL)
2471     *minimum = height;
2472   if (natural != NULL)
2473     *natural = height;
2474 }
2475
2476 static void
2477 gtk_tree_view_modify_column_width (GtkTreeView       *tree_view,
2478                                    GtkTreeViewColumn *column,
2479                                    gint               width)
2480 {
2481   gboolean is_expand;
2482   gint n_expand_others;
2483   gint minimum, natural, natural_others;
2484   gint expand;
2485
2486   is_expand = gtk_tree_view_column_get_expand (column);
2487   n_expand_others = tree_view->priv->n_expand_columns - (is_expand ? 1 : 0);
2488
2489   _gtk_tree_view_column_request_width (column, &minimum, &natural);
2490   natural_others = tree_view->priv->natural_width - natural;
2491
2492   if (natural_others + width < tree_view->priv->width)
2493     {
2494       /* There is extra space that needs to be taken up by letting some other
2495        * column(s) expand: by default, the last column. */
2496       if (!n_expand_others)
2497         {
2498           GList *last = g_list_last (tree_view->priv->columns);
2499           while (!gtk_tree_view_column_get_visible (last->data))
2500             last = last->prev;
2501
2502           if (column == last->data)
2503             return;
2504
2505           gtk_tree_view_column_set_expand (last->data, TRUE);
2506           n_expand_others++;
2507         }
2508
2509       /* Now try to make this column expandable also.  Solving the following
2510        * equations reveals what the natural width should be to achieve the
2511        * desired width after expanding:
2512        *
2513        *   1. natural + expand = desired_width
2514        *   2. natural + natural_others + expand * (n_expand_others + 1) = total_width
2515        *
2516        * Solution:
2517        *   expand = (total_width - natural_others - desired_width) / n_expand_others
2518        *
2519        * It is possible for the solved natural width to be less than the
2520        * minimum; in that case, we cannot let the column expand.
2521        */
2522       expand = (tree_view->priv->width - natural_others - width) / n_expand_others;
2523
2524       if (minimum + expand > width)
2525         {
2526           if (is_expand)
2527             gtk_tree_view_column_set_expand (column, FALSE);
2528         }
2529       else
2530         {
2531           if (!is_expand)
2532             gtk_tree_view_column_set_expand (column, TRUE);
2533
2534           width -= expand;
2535         }
2536     }
2537
2538   gtk_tree_view_column_set_fixed_width (column, width);
2539 }
2540
2541 static int
2542 gtk_tree_view_calculate_width_before_expander (GtkTreeView *tree_view)
2543 {
2544   int width = 0;
2545   GList *list;
2546   gboolean rtl;
2547
2548   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2549   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2550        list->data != tree_view->priv->expander_column;
2551        list = (rtl ? list->prev : list->next))
2552     {
2553       GtkTreeViewColumn *column = list->data;
2554
2555       width += gtk_tree_view_column_get_width (column);
2556     }
2557
2558   return width;
2559 }
2560
2561 /* GtkWidget::size_allocate helper */
2562 static void
2563 gtk_tree_view_size_allocate_columns (GtkWidget *widget,
2564                                      gboolean  *width_changed)
2565 {
2566   GtkTreeView *tree_view;
2567   GList *list, *first_column, *last_column;
2568   GtkTreeViewColumn *column;
2569   GtkAllocation widget_allocation;
2570   gint minimum_width, natural_width, n_expand_columns, width;
2571   gint column_minimum, column_natural, column_width;
2572   gboolean rtl;
2573
2574   tree_view = GTK_TREE_VIEW (widget);
2575
2576   for (last_column = g_list_last (tree_view->priv->columns);
2577        last_column &&
2578        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
2579        last_column = last_column->prev)
2580     ;
2581   if (last_column == NULL)
2582     return;
2583
2584   for (first_column = g_list_first (tree_view->priv->columns);
2585        first_column &&
2586        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
2587        first_column = first_column->next)
2588     ;
2589
2590   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2591
2592   gtk_widget_get_allocation (widget, &widget_allocation);
2593
2594   minimum_width = tree_view->priv->minimum_width;
2595   natural_width = tree_view->priv->natural_width;
2596   n_expand_columns = tree_view->priv->n_expand_columns;
2597
2598   width = MAX (widget_allocation.width, minimum_width);
2599
2600   /* We change the width here.  The user might have been resizing columns,
2601    * which changes the total width of the tree view.  This is of
2602    * importance for getting the horizontal scroll bar right.
2603    */
2604   if (tree_view->priv->width != width)
2605     {
2606       tree_view->priv->width = width;
2607       if (width_changed)
2608         *width_changed = TRUE;
2609     }
2610
2611   /* iterate through columns in reverse order */
2612   for (list = (rtl ? first_column : last_column);
2613        list != (rtl ? last_column->next : first_column->prev);
2614        list = (rtl ? list->next : list->prev))
2615     {
2616       column = list->data;
2617
2618       if (!gtk_tree_view_column_get_visible (column) || column == tree_view->priv->drag_column)
2619         continue;
2620
2621       _gtk_tree_view_column_request_width (column, &column_minimum, &column_natural);
2622
2623       column_width = column_natural;
2624
2625       if (width > natural_width)
2626         {
2627           /* We need to expand some columns.  If there are none marked to
2628            * expand, give all the extra space to the last column. */
2629           if (n_expand_columns == 0)
2630             {
2631               column_width = column_natural + (width - natural_width);
2632             }
2633           else if (gtk_tree_view_column_get_expand (column))
2634             {
2635               column_width = column_natural + (width - natural_width) / n_expand_columns;
2636               n_expand_columns--;
2637             }
2638         }
2639       else if (width < natural_width)
2640         {
2641           /* We need to shrink some columns.  Starting with later columns,
2642            * shrink each one down to its minimum width as necessary. */
2643           column_width = MAX (column_natural + (width - natural_width), column_minimum);
2644         }
2645
2646       _gtk_tree_view_column_allocate (column, width - column_width, column_width);
2647
2648       minimum_width -= column_minimum;
2649       natural_width -= column_natural;
2650       width -= column_width;
2651     }
2652 }
2653
2654 /* GtkWidget::size_allocate helper */
2655 static void
2656 gtk_tree_view_size_allocate_drag_column (GtkWidget *widget)
2657 {
2658   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2659   GtkAllocation drag_allocation;
2660   GtkWidget *button;
2661
2662   if (tree_view->priv->drag_column == NULL)
2663     return;
2664
2665   button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
2666
2667   drag_allocation.x = 0;
2668   drag_allocation.y = 0;
2669   drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
2670   drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
2671   gtk_widget_size_allocate (button, &drag_allocation);
2672 }
2673
2674 static void
2675 gtk_tree_view_size_allocate (GtkWidget     *widget,
2676                              GtkAllocation *allocation)
2677 {
2678   GtkAllocation widget_allocation;
2679   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2680   GList *tmp_list;
2681   gboolean width_changed = FALSE;
2682   gint old_width;
2683
2684   gtk_widget_get_allocation (widget, &widget_allocation);
2685   old_width = widget_allocation.width;
2686   if (allocation->width != widget_allocation.width)
2687     width_changed = TRUE;
2688
2689   gtk_widget_set_allocation (widget, allocation);
2690
2691   tmp_list = tree_view->priv->children;
2692
2693   while (tmp_list)
2694     {
2695       GtkAllocation allocation;
2696
2697       GtkTreeViewChild *child = tmp_list->data;
2698       tmp_list = tmp_list->next;
2699
2700       /* totally ignore our child's requisition */
2701       allocation.x = child->x;
2702       allocation.y = child->y;
2703       allocation.width = child->width;
2704       allocation.height = child->height;
2705       gtk_widget_size_allocate (child->widget, &allocation);
2706     }
2707
2708   /* We size-allocate the columns first because the width of the
2709    * tree view (used in updating the adjustments below) might change.
2710    */
2711   gtk_tree_view_size_allocate_columns (widget, &width_changed);
2712   gtk_tree_view_size_allocate_drag_column (widget);
2713
2714   g_object_freeze_notify (G_OBJECT (tree_view->priv->hadjustment));
2715   gtk_adjustment_set_page_size (tree_view->priv->hadjustment,
2716                                 allocation->width);
2717   gtk_adjustment_set_page_increment (tree_view->priv->hadjustment,
2718                                      allocation->width * 0.9);
2719   gtk_adjustment_set_step_increment (tree_view->priv->hadjustment,
2720                                      allocation->width * 0.1);
2721   gtk_adjustment_set_lower (tree_view->priv->hadjustment, 0);
2722   gtk_adjustment_set_upper (tree_view->priv->hadjustment,
2723                             MAX (gtk_adjustment_get_page_size (tree_view->priv->hadjustment),
2724                                  tree_view->priv->width));
2725   g_object_thaw_notify (G_OBJECT (tree_view->priv->hadjustment));
2726
2727   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2728     {
2729       if (allocation->width < tree_view->priv->width)
2730         {
2731           if (tree_view->priv->init_hadjust_value)
2732             {
2733               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2734                                         MAX (tree_view->priv->width -
2735                                              allocation->width, 0));
2736               tree_view->priv->init_hadjust_value = FALSE;
2737             }
2738           else if (allocation->width != old_width)
2739             {
2740               gtk_adjustment_set_value (tree_view->priv->hadjustment,
2741                                         CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) - allocation->width + old_width,
2742                                                0,
2743                                                tree_view->priv->width - allocation->width));
2744             }
2745         }
2746       else
2747         {
2748           gtk_adjustment_set_value (tree_view->priv->hadjustment, 0);
2749           tree_view->priv->init_hadjust_value = TRUE;
2750         }
2751     }
2752   else
2753     if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + allocation->width > tree_view->priv->width)
2754       gtk_adjustment_set_value (tree_view->priv->hadjustment,
2755                                 MAX (tree_view->priv->width -
2756                                      allocation->width, 0));
2757
2758   g_object_freeze_notify (G_OBJECT (tree_view->priv->vadjustment));
2759   gtk_adjustment_set_page_size (tree_view->priv->vadjustment,
2760                                 allocation->height -
2761                                 gtk_tree_view_get_effective_header_height (tree_view));
2762   gtk_adjustment_set_step_increment (tree_view->priv->vadjustment,
2763                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.1);
2764   gtk_adjustment_set_page_increment (tree_view->priv->vadjustment,
2765                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.9);
2766   gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
2767   gtk_adjustment_set_upper (tree_view->priv->vadjustment,
2768                             MAX (gtk_adjustment_get_page_size (tree_view->priv->vadjustment),
2769                                  tree_view->priv->height));
2770   g_object_thaw_notify (G_OBJECT (tree_view->priv->vadjustment));
2771
2772   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2773   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
2774     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2775   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
2776     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2777                               tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
2778   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2779     gtk_tree_view_top_row_to_dy (tree_view);
2780   else
2781     gtk_tree_view_dy_to_top_row (tree_view);
2782
2783   if (gtk_widget_get_realized (widget))
2784     {
2785       gdk_window_move_resize (gtk_widget_get_window (widget),
2786                               allocation->x, allocation->y,
2787                               allocation->width, allocation->height);
2788       gdk_window_move_resize (tree_view->priv->header_window,
2789                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2790                               0,
2791                               MAX (tree_view->priv->width, allocation->width),
2792                               tree_view->priv->header_height);
2793       gdk_window_move_resize (tree_view->priv->bin_window,
2794                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2795                               gtk_tree_view_get_effective_header_height (tree_view),
2796                               MAX (tree_view->priv->width, allocation->width),
2797                               allocation->height - gtk_tree_view_get_effective_header_height (tree_view));
2798
2799       if (tree_view->priv->tree == NULL)
2800         invalidate_empty_focus (tree_view);
2801
2802       if (width_changed && tree_view->priv->expander_column)
2803         {
2804           /* Might seem awkward, but is the best heuristic I could come up
2805            * with.  Only if the width of the columns before the expander
2806            * changes, we will update the prelight status.  It is this
2807            * width that makes the expander move vertically.  Always updating
2808            * prelight status causes trouble with hover selections.
2809            */
2810           gint width_before_expander;
2811
2812           width_before_expander = gtk_tree_view_calculate_width_before_expander (tree_view);
2813
2814           if (tree_view->priv->prev_width_before_expander
2815               != width_before_expander)
2816               update_prelight (tree_view,
2817                                tree_view->priv->event_last_x,
2818                                tree_view->priv->event_last_y);
2819
2820           tree_view->priv->prev_width_before_expander = width_before_expander;
2821         }
2822     }
2823 }
2824
2825 /* Grabs the focus and unsets the GTK_TREE_VIEW_DRAW_KEYFOCUS flag */
2826 static void
2827 grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
2828 {
2829   GtkWidget *widget = GTK_WIDGET (tree_view);
2830
2831   if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
2832     gtk_widget_grab_focus (widget);
2833   tree_view->priv->draw_keyfocus = 0;
2834 }
2835
2836 static inline gboolean
2837 row_is_separator (GtkTreeView *tree_view,
2838                   GtkTreeIter *iter,
2839                   GtkTreePath *path)
2840 {
2841   gboolean is_separator = FALSE;
2842
2843   if (tree_view->priv->row_separator_func)
2844     {
2845       GtkTreeIter tmpiter;
2846
2847       if (iter)
2848         tmpiter = *iter;
2849       else
2850         {
2851           if (!gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path))
2852             return FALSE;
2853         }
2854
2855       is_separator = tree_view->priv->row_separator_func (tree_view->priv->model,
2856                                                           &tmpiter,
2857                                                           tree_view->priv->row_separator_data);
2858     }
2859
2860   return is_separator;
2861 }
2862
2863 static int
2864 gtk_tree_view_get_expander_size (GtkTreeView *tree_view)
2865 {
2866   gint expander_size;
2867   gint horizontal_separator;
2868
2869   gtk_widget_style_get (GTK_WIDGET (tree_view),
2870                         "expander-size", &expander_size,
2871                         "horizontal-separator", &horizontal_separator,
2872                         NULL);
2873
2874   return expander_size + (horizontal_separator / 2);
2875 }
2876
2877 static gboolean
2878 gtk_tree_view_button_press (GtkWidget      *widget,
2879                             GdkEventButton *event)
2880 {
2881   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2882   GList *list;
2883   GtkTreeViewColumn *column = NULL;
2884   gint i;
2885   GdkRectangle background_area;
2886   GdkRectangle cell_area;
2887   gint vertical_separator;
2888   gint horizontal_separator;
2889   gboolean path_is_selectable;
2890   gboolean rtl;
2891
2892   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2893   gtk_tree_view_stop_editing (tree_view, FALSE);
2894   gtk_widget_style_get (widget,
2895                         "vertical-separator", &vertical_separator,
2896                         "horizontal-separator", &horizontal_separator,
2897                         NULL);
2898
2899   /* Don't handle extra mouse buttons events, let them bubble up */
2900   if (event->button > 5)
2901     return FALSE;
2902
2903   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2904    * we're done handling the button press.
2905    */
2906
2907   if (event->window == tree_view->priv->bin_window)
2908     {
2909       GtkRBNode *node;
2910       GtkRBTree *tree;
2911       GtkTreePath *path;
2912       gint depth;
2913       gint new_y;
2914       gint y_offset;
2915       gint dval;
2916       gint pre_val, aft_val;
2917       GtkTreeViewColumn *column = NULL;
2918       gint column_handled_click = FALSE;
2919       gboolean row_double_click = FALSE;
2920       gboolean rtl;
2921       gboolean node_selected;
2922       GdkModifierType extend_mod_mask;
2923       GdkModifierType modify_mod_mask;
2924
2925       /* Empty tree? */
2926       if (tree_view->priv->tree == NULL)
2927         {
2928           grab_focus_and_unset_draw_keyfocus (tree_view);
2929           return TRUE;
2930         }
2931
2932       /* are we in an arrow? */
2933       if (tree_view->priv->prelight_node &&
2934           tree_view->priv->arrow_prelit &&
2935           gtk_tree_view_draw_expanders (tree_view))
2936         {
2937           if (event->button == GDK_BUTTON_PRIMARY)
2938             {
2939               gtk_grab_add (widget);
2940               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2941               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2942               gtk_tree_view_queue_draw_arrow (GTK_TREE_VIEW (widget),
2943                                               tree_view->priv->prelight_tree,
2944                                               tree_view->priv->prelight_node);
2945             }
2946
2947           grab_focus_and_unset_draw_keyfocus (tree_view);
2948           return TRUE;
2949         }
2950
2951       /* find the node that was clicked */
2952       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
2953       if (new_y < 0)
2954         new_y = 0;
2955       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
2956
2957       if (node == NULL)
2958         {
2959           /* We clicked in dead space */
2960           grab_focus_and_unset_draw_keyfocus (tree_view);
2961           return TRUE;
2962         }
2963
2964       /* Get the path and the node */
2965       path = _gtk_tree_path_new_from_rbtree (tree, node);
2966       path_is_selectable = !row_is_separator (tree_view, NULL, path);
2967
2968       if (!path_is_selectable)
2969         {
2970           gtk_tree_path_free (path);
2971           grab_focus_and_unset_draw_keyfocus (tree_view);
2972           return TRUE;
2973         }
2974
2975       depth = gtk_tree_path_get_depth (path);
2976       background_area.y = y_offset + event->y;
2977       background_area.height = gtk_tree_view_get_row_height (tree_view, node);
2978       background_area.x = 0;
2979
2980
2981       /* Let the column have a chance at selecting it. */
2982       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2983       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2984            list; list = (rtl ? list->prev : list->next))
2985         {
2986           GtkTreeViewColumn *candidate = list->data;
2987
2988           if (!gtk_tree_view_column_get_visible (candidate))
2989             continue;
2990
2991           background_area.width = gtk_tree_view_column_get_width (candidate);
2992           if ((background_area.x > (gint) event->x) ||
2993               (background_area.x + background_area.width <= (gint) event->x))
2994             {
2995               background_area.x += background_area.width;
2996               continue;
2997             }
2998
2999           /* we found the focus column */
3000           column = candidate;
3001           cell_area = background_area;
3002           cell_area.width -= horizontal_separator;
3003           cell_area.height -= vertical_separator;
3004           cell_area.x += horizontal_separator/2;
3005           cell_area.y += vertical_separator/2;
3006           if (gtk_tree_view_is_expander_column (tree_view, column))
3007             {
3008               if (!rtl)
3009                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
3010               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
3011
3012               if (gtk_tree_view_draw_expanders (tree_view))
3013                 {
3014                   gint expander_size = gtk_tree_view_get_expander_size (tree_view);
3015                   if (!rtl)
3016                     cell_area.x += depth * expander_size;
3017                   cell_area.width -= depth * expander_size;
3018                 }
3019             }
3020           break;
3021         }
3022
3023       if (column == NULL)
3024         {
3025           gtk_tree_path_free (path);
3026           grab_focus_and_unset_draw_keyfocus (tree_view);
3027           return FALSE;
3028         }
3029
3030       _gtk_tree_view_set_focus_column (tree_view, column);
3031
3032       /* decide if we edit */
3033       if (event->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_PRIMARY &&
3034           !(event->state & gtk_accelerator_get_default_mod_mask ()))
3035         {
3036           GtkTreePath *anchor;
3037           GtkTreeIter iter;
3038
3039           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
3040           gtk_tree_view_column_cell_set_cell_data (column,
3041                                                    tree_view->priv->model,
3042                                                    &iter,
3043                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
3044                                                    node->children?TRUE:FALSE);
3045
3046           if (tree_view->priv->anchor)
3047             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
3048           else
3049             anchor = NULL;
3050
3051           if ((anchor && !gtk_tree_path_compare (anchor, path))
3052               || !_gtk_tree_view_column_has_editable_cell (column))
3053             {
3054               GtkCellEditable *cell_editable = NULL;
3055
3056               /* FIXME: get the right flags */
3057               guint flags = 0;
3058
3059               if (_gtk_tree_view_column_cell_event (column,
3060                                                     (GdkEvent *)event,
3061                                                     &cell_area, flags))
3062                 {
3063                   GtkCellArea *area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
3064                   cell_editable = gtk_cell_area_get_edit_widget (area);
3065
3066                   if (cell_editable != NULL)
3067                     {
3068                       gtk_tree_path_free (path);
3069                       gtk_tree_path_free (anchor);
3070                       return TRUE;
3071                     }
3072                   column_handled_click = TRUE;
3073                 }
3074             }
3075           if (anchor)
3076             gtk_tree_path_free (anchor);
3077         }
3078
3079       extend_mod_mask =
3080         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
3081
3082       modify_mod_mask =
3083         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
3084
3085       /* select */
3086       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
3087       pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3088
3089       /* we only handle selection modifications on the first button press
3090        */
3091       if (event->type == GDK_BUTTON_PRESS)
3092         {
3093           GtkCellRenderer *focus_cell;
3094
3095           if ((event->state & modify_mod_mask) == modify_mod_mask)
3096             tree_view->priv->modify_selection_pressed = TRUE;
3097           if ((event->state & extend_mod_mask) == extend_mod_mask)
3098             tree_view->priv->extend_selection_pressed = TRUE;
3099
3100           /* We update the focus cell here, this is also needed if the
3101            * column does not contain an editable cell.  In this case,
3102            * GtkCellArea did not receive the event for processing (and
3103            * could not update the focus cell).
3104            */
3105           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column,
3106                                                               &cell_area,
3107                                                               &background_area,
3108                                                               event->x,
3109                                                               event->y);
3110
3111           if (focus_cell)
3112             gtk_tree_view_column_focus_cell (column, focus_cell);
3113
3114           if (event->state & modify_mod_mask)
3115             {
3116               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3117               gtk_tree_view_real_toggle_cursor_row (tree_view);
3118             }
3119           else if (event->state & extend_mod_mask)
3120             {
3121               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3122               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
3123             }
3124           else
3125             {
3126               gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
3127             }
3128
3129           tree_view->priv->modify_selection_pressed = FALSE;
3130           tree_view->priv->extend_selection_pressed = FALSE;
3131         }
3132
3133       /* the treeview may have been scrolled because of _set_cursor,
3134        * correct here
3135        */
3136
3137       aft_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3138       dval = pre_val - aft_val;
3139
3140       cell_area.y += dval;
3141       background_area.y += dval;
3142
3143       /* Save press to possibly begin a drag
3144        */
3145       if (!column_handled_click &&
3146           !tree_view->priv->in_grab &&
3147           tree_view->priv->pressed_button < 0)
3148         {
3149           tree_view->priv->pressed_button = event->button;
3150           tree_view->priv->press_start_x = event->x;
3151           tree_view->priv->press_start_y = event->y;
3152
3153           if (tree_view->priv->rubber_banding_enable
3154               && !node_selected
3155               && gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
3156             {
3157               tree_view->priv->press_start_y += tree_view->priv->dy;
3158               tree_view->priv->rubber_band_x = event->x;
3159               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
3160               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
3161
3162               if ((event->state & modify_mod_mask) == modify_mod_mask)
3163                 tree_view->priv->rubber_band_modify = TRUE;
3164               if ((event->state & extend_mod_mask) == extend_mod_mask)
3165                 tree_view->priv->rubber_band_extend = TRUE;
3166             }
3167         }
3168
3169       if (event->button == GDK_BUTTON_PRIMARY && event->type == GDK_BUTTON_PRESS)
3170         {
3171
3172           /* Test if a double click happened on the same row. */
3173           if (!tree_view->priv->activate_on_single_click)
3174             {
3175               int double_click_time, double_click_distance;
3176
3177               g_object_get (gtk_settings_get_default (),
3178                             "gtk-double-click-time", &double_click_time,
3179                             "gtk-double-click-distance", &double_click_distance,
3180                             NULL);
3181
3182               /* Same conditions as _gdk_event_button_generate */
3183               if (tree_view->priv->last_button_x != -1 &&
3184                   (event->time < tree_view->priv->last_button_time + double_click_time) &&
3185                   (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
3186                   (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
3187                 {
3188                   /* We do no longer compare paths of this row and the
3189                    * row clicked previously.  We use the double click
3190                    * distance to decide whether this is a valid click,
3191                    * allowing the mouse to slightly move over another row.
3192                    */
3193                   row_double_click = TRUE;
3194
3195                   tree_view->priv->last_button_time = 0;
3196                   tree_view->priv->last_button_x = -1;
3197                   tree_view->priv->last_button_y = -1;
3198                 }
3199               else
3200                 {
3201                   tree_view->priv->last_button_time = event->time;
3202                   tree_view->priv->last_button_x = event->x;
3203                   tree_view->priv->last_button_y = event->y;
3204                 }
3205             }
3206           else
3207             {
3208               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
3209               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
3210             }
3211         }
3212
3213       if (row_double_click)
3214         {
3215           gtk_grab_remove (widget);
3216           gtk_tree_view_row_activated (tree_view, path, column);
3217
3218           if (tree_view->priv->pressed_button == event->button)
3219             tree_view->priv->pressed_button = -1;
3220         }
3221
3222       gtk_tree_path_free (path);
3223
3224       /* If we activated the row through a double click we don't want to grab
3225        * focus back, as moving focus to another widget is pretty common.
3226        */
3227       if (!row_double_click)
3228         grab_focus_and_unset_draw_keyfocus (tree_view);
3229
3230       return TRUE;
3231     }
3232
3233   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
3234    */
3235   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
3236     {
3237       column = list->data;
3238       if (event->window == _gtk_tree_view_column_get_window (column) &&
3239           gtk_tree_view_column_get_resizable (column) &&
3240           _gtk_tree_view_column_get_window (column))
3241         {
3242           gpointer drag_data;
3243           gint column_width, x;
3244
3245           if (event->type == GDK_2BUTTON_PRESS &&
3246               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
3247             {
3248               gtk_tree_view_column_set_fixed_width (column, -1);
3249               gtk_tree_view_column_set_expand (column, FALSE);
3250               _gtk_tree_view_column_autosize (tree_view, column);
3251               return TRUE;
3252             }
3253
3254           if (gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
3255                                _gtk_tree_view_column_get_window (column),
3256                                GDK_OWNERSHIP_NONE,
3257                                FALSE,
3258                                GDK_POINTER_MOTION_HINT_MASK
3259                                 | GDK_BUTTON1_MOTION_MASK
3260                                 | GDK_BUTTON_RELEASE_MASK,
3261                                NULL,
3262                                event->time) != GDK_GRAB_SUCCESS)
3263             return FALSE;
3264
3265           gtk_grab_add (widget);
3266           tree_view->priv->in_column_resize = TRUE;
3267
3268           /* block attached dnd signal handler */
3269           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3270           if (drag_data)
3271             g_signal_handlers_block_matched (widget,
3272                                              G_SIGNAL_MATCH_DATA,
3273                                              0, 0, NULL, NULL,
3274                                              drag_data);
3275
3276           column_width = gtk_tree_view_column_get_width (column);
3277           gdk_window_get_device_position (tree_view->priv->bin_window,
3278                                           gdk_event_get_device ((GdkEvent *) event),
3279                                           &x, NULL, NULL);
3280
3281           tree_view->priv->drag_pos = i;
3282           tree_view->priv->x_drag = x + (rtl ? column_width : -column_width);
3283
3284           if (!gtk_widget_has_focus (widget))
3285             gtk_widget_grab_focus (widget);
3286
3287           return TRUE;
3288         }
3289     }
3290   return FALSE;
3291 }
3292
3293 /* GtkWidget::button_release_event helper */
3294 static gboolean
3295 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
3296                                           GdkEventButton *event)
3297 {
3298   GtkTreeView *tree_view;
3299   GtkWidget *button;
3300   GList *l;
3301   gboolean rtl;
3302   GdkDevice *device, *other;
3303   GtkStyleContext *context;
3304
3305   tree_view = GTK_TREE_VIEW (widget);
3306
3307   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
3308   device = gdk_event_get_device ((GdkEvent*)event);
3309   other = gdk_device_get_associated_device (device);
3310   gdk_device_ungrab (device, event->time);
3311   gdk_device_ungrab (other, event->time);
3312
3313   /* Move the button back */
3314   button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3315
3316   context = gtk_widget_get_style_context (button);
3317   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_DND);
3318
3319   g_object_ref (button);
3320   gtk_container_remove (GTK_CONTAINER (tree_view), button);
3321   gtk_widget_set_parent_window (button, tree_view->priv->header_window);
3322   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
3323   g_object_unref (button);
3324   gtk_widget_queue_resize (widget);
3325   if (gtk_tree_view_column_get_resizable (tree_view->priv->drag_column))
3326     {
3327       gdk_window_raise (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3328       gdk_window_show (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3329     }
3330   else
3331     gdk_window_hide (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3332
3333   gtk_widget_grab_focus (button);
3334
3335   if (rtl)
3336     {
3337       if (tree_view->priv->cur_reorder &&
3338           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
3339         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3340                                          tree_view->priv->cur_reorder->right_column);
3341     }
3342   else
3343     {
3344       if (tree_view->priv->cur_reorder &&
3345           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
3346         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3347                                          tree_view->priv->cur_reorder->left_column);
3348     }
3349   tree_view->priv->drag_column = NULL;
3350   gtk_widget_unregister_window (widget, tree_view->priv->drag_window);
3351   gdk_window_destroy (tree_view->priv->drag_window);
3352   tree_view->priv->drag_window = NULL;
3353
3354   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
3355     g_slice_free (GtkTreeViewColumnReorder, l->data);
3356   g_list_free (tree_view->priv->column_drag_info);
3357   tree_view->priv->column_drag_info = NULL;
3358   tree_view->priv->cur_reorder = NULL;
3359
3360   if (tree_view->priv->drag_highlight_window)
3361     gdk_window_hide (tree_view->priv->drag_highlight_window);
3362
3363   /* Reset our flags */
3364   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
3365   tree_view->priv->in_column_drag = FALSE;
3366
3367   return TRUE;
3368 }
3369
3370 /* GtkWidget::button_release_event helper */
3371 static gboolean
3372 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
3373                                             GdkEventButton *event)
3374 {
3375   GtkTreeView *tree_view;
3376   gpointer drag_data;
3377
3378   tree_view = GTK_TREE_VIEW (widget);
3379
3380   tree_view->priv->drag_pos = -1;
3381
3382   /* unblock attached dnd signal handler */
3383   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3384   if (drag_data)
3385     g_signal_handlers_unblock_matched (widget,
3386                                        G_SIGNAL_MATCH_DATA,
3387                                        0, 0, NULL, NULL,
3388                                        drag_data);
3389
3390   tree_view->priv->in_column_resize = FALSE;
3391   gtk_grab_remove (widget);
3392   gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
3393   return TRUE;
3394 }
3395
3396 static gboolean
3397 button_event_modifies_selection (GdkEventButton *event)
3398 {
3399         return (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) != 0;
3400 }
3401
3402 static gboolean
3403 gtk_tree_view_button_release (GtkWidget      *widget,
3404                               GdkEventButton *event)
3405 {
3406   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3407
3408   if (tree_view->priv->in_column_drag)
3409     return gtk_tree_view_button_release_drag_column (widget, event);
3410
3411   if (tree_view->priv->rubber_band_status)
3412     gtk_tree_view_stop_rubber_band (tree_view);
3413
3414   if (tree_view->priv->pressed_button == event->button)
3415     tree_view->priv->pressed_button = -1;
3416
3417   if (tree_view->priv->in_column_resize)
3418     return gtk_tree_view_button_release_column_resize (widget, event);
3419
3420   if (tree_view->priv->button_pressed_node == NULL)
3421     return FALSE;
3422
3423   if (event->button == GDK_BUTTON_PRIMARY
3424       && tree_view->priv->button_pressed_node == tree_view->priv->prelight_node)
3425     {
3426       if (tree_view->priv->arrow_prelit)
3427         {
3428           GtkTreePath *path = NULL;
3429
3430           path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
3431                                                  tree_view->priv->button_pressed_node);
3432           /* Actually activate the node */
3433           if (tree_view->priv->button_pressed_node->children == NULL)
3434             gtk_tree_view_real_expand_row (tree_view, path,
3435                                            tree_view->priv->button_pressed_tree,
3436                                            tree_view->priv->button_pressed_node,
3437                                            FALSE, TRUE);
3438           else
3439             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3440                                              tree_view->priv->button_pressed_tree,
3441                                              tree_view->priv->button_pressed_node, TRUE);
3442           gtk_tree_path_free (path);
3443         }
3444       else if (tree_view->priv->activate_on_single_click
3445                && !button_event_modifies_selection (event))
3446         {
3447           GtkTreePath *path = NULL;
3448
3449           path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
3450                                                  tree_view->priv->button_pressed_node);
3451           gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
3452           gtk_tree_path_free (path);
3453         }
3454
3455       gtk_grab_remove (widget);
3456       tree_view->priv->button_pressed_tree = NULL;
3457       tree_view->priv->button_pressed_node = NULL;
3458     }
3459
3460   return TRUE;
3461 }
3462
3463 static gboolean
3464 gtk_tree_view_grab_broken (GtkWidget          *widget,
3465                            GdkEventGrabBroken *event)
3466 {
3467   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3468
3469   if (tree_view->priv->in_column_drag)
3470     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3471
3472   if (tree_view->priv->in_column_resize)
3473     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3474
3475   return TRUE;
3476 }
3477
3478 #if 0
3479 static gboolean
3480 gtk_tree_view_configure (GtkWidget *widget,
3481                          GdkEventConfigure *event)
3482 {
3483   GtkTreeView *tree_view;
3484
3485   tree_view = GTK_TREE_VIEW (widget);
3486   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3487
3488   return FALSE;
3489 }
3490 #endif
3491
3492 /* GtkWidget::motion_event function set.
3493  */
3494
3495 static gboolean
3496 coords_are_over_arrow (GtkTreeView *tree_view,
3497                        GtkRBTree   *tree,
3498                        GtkRBNode   *node,
3499                        /* these are in bin window coords */
3500                        gint         x,
3501                        gint         y)
3502 {
3503   GdkRectangle arrow;
3504   gint x2;
3505
3506   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
3507     return FALSE;
3508
3509   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3510     return FALSE;
3511
3512   arrow.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
3513   arrow.height = gtk_tree_view_get_row_height (tree_view, node);
3514
3515   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3516
3517   arrow.width = x2 - arrow.x;
3518
3519   return (x >= arrow.x &&
3520           x < (arrow.x + arrow.width) &&
3521           y >= arrow.y &&
3522           y < (arrow.y + arrow.height));
3523 }
3524
3525 static gboolean
3526 auto_expand_timeout (gpointer data)
3527 {
3528   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3529   GtkTreePath *path;
3530
3531   if (tree_view->priv->prelight_node)
3532     {
3533       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->prelight_tree,
3534                                              tree_view->priv->prelight_node);
3535
3536       if (tree_view->priv->prelight_node->children)
3537         gtk_tree_view_collapse_row (tree_view, path);
3538       else
3539         gtk_tree_view_expand_row (tree_view, path, FALSE);
3540
3541       gtk_tree_path_free (path);
3542     }
3543
3544   tree_view->priv->auto_expand_timeout = 0;
3545
3546   return FALSE;
3547 }
3548
3549 static void
3550 remove_auto_expand_timeout (GtkTreeView *tree_view)
3551 {
3552   if (tree_view->priv->auto_expand_timeout != 0)
3553     {
3554       g_source_remove (tree_view->priv->auto_expand_timeout);
3555       tree_view->priv->auto_expand_timeout = 0;
3556     }
3557 }
3558
3559 static void
3560 do_prelight (GtkTreeView *tree_view,
3561              GtkRBTree   *tree,
3562              GtkRBNode   *node,
3563              /* these are in bin_window coords */
3564              gint         x,
3565              gint         y)
3566 {
3567   if (tree_view->priv->prelight_tree == tree &&
3568       tree_view->priv->prelight_node == node)
3569     {
3570       /*  We are still on the same node,
3571           but we might need to take care of the arrow  */
3572
3573       if (tree && node && gtk_tree_view_draw_expanders (tree_view))
3574         {
3575           gboolean over_arrow;
3576
3577           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3578
3579           if (over_arrow != tree_view->priv->arrow_prelit)
3580             {
3581               if (over_arrow)
3582                 tree_view->priv->arrow_prelit = TRUE;
3583               else
3584                 tree_view->priv->arrow_prelit = FALSE;
3585
3586               gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3587             }
3588         }
3589
3590       return;
3591     }
3592
3593   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3594     {
3595       /*  Unprelight the old node and arrow  */
3596
3597       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3598                              GTK_RBNODE_IS_PRELIT);
3599
3600       if (tree_view->priv->arrow_prelit
3601           && gtk_tree_view_draw_expanders (tree_view))
3602         {
3603           tree_view->priv->arrow_prelit = FALSE;
3604
3605           gtk_tree_view_queue_draw_arrow (tree_view,
3606                                           tree_view->priv->prelight_tree,
3607                                           tree_view->priv->prelight_node);
3608         }
3609
3610       _gtk_tree_view_queue_draw_node (tree_view,
3611                                       tree_view->priv->prelight_tree,
3612                                       tree_view->priv->prelight_node,
3613                                       NULL);
3614     }
3615
3616
3617   if (tree_view->priv->hover_expand)
3618     remove_auto_expand_timeout (tree_view);
3619
3620   /*  Set the new prelight values  */
3621   tree_view->priv->prelight_node = node;
3622   tree_view->priv->prelight_tree = tree;
3623
3624   if (!node || !tree)
3625     return;
3626
3627   /*  Prelight the new node and arrow  */
3628
3629   if (gtk_tree_view_draw_expanders (tree_view)
3630       && coords_are_over_arrow (tree_view, tree, node, x, y))
3631     {
3632       tree_view->priv->arrow_prelit = TRUE;
3633
3634       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3635     }
3636
3637   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3638
3639   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3640
3641   if (tree_view->priv->hover_expand)
3642     {
3643       tree_view->priv->auto_expand_timeout =
3644         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3645     }
3646 }
3647
3648 static void
3649 prelight_or_select (GtkTreeView *tree_view,
3650                     GtkRBTree   *tree,
3651                     GtkRBNode   *node,
3652                     /* these are in bin_window coords */
3653                     gint         x,
3654                     gint         y)
3655 {
3656   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3657
3658   if (tree_view->priv->hover_selection &&
3659       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3660       !(tree_view->priv->edited_column &&
3661         gtk_cell_area_get_edit_widget
3662         (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column)))))
3663     {
3664       if (node)
3665         {
3666           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3667             {
3668               GtkTreePath *path;
3669
3670               path = _gtk_tree_path_new_from_rbtree (tree, node);
3671               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3672               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3673                 {
3674                   tree_view->priv->draw_keyfocus = FALSE;
3675                   gtk_tree_view_real_set_cursor (tree_view, path, 0);
3676                 }
3677               gtk_tree_path_free (path);
3678             }
3679         }
3680
3681       else if (mode == GTK_SELECTION_SINGLE)
3682         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3683     }
3684
3685     do_prelight (tree_view, tree, node, x, y);
3686 }
3687
3688 static void
3689 ensure_unprelighted (GtkTreeView *tree_view)
3690 {
3691   do_prelight (tree_view,
3692                NULL, NULL,
3693                -1000, -1000); /* coords not possibly over an arrow */
3694
3695   g_assert (tree_view->priv->prelight_node == NULL);
3696 }
3697
3698 static void
3699 update_prelight (GtkTreeView *tree_view,
3700                  gint         x,
3701                  gint         y)
3702 {
3703   int new_y;
3704   GtkRBTree *tree;
3705   GtkRBNode *node;
3706
3707   if (tree_view->priv->tree == NULL)
3708     return;
3709
3710   if (x == -10000)
3711     {
3712       ensure_unprelighted (tree_view);
3713       return;
3714     }
3715
3716   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
3717   if (new_y < 0)
3718     new_y = 0;
3719
3720   _gtk_rbtree_find_offset (tree_view->priv->tree,
3721                            new_y, &tree, &node);
3722
3723   if (node)
3724     prelight_or_select (tree_view, tree, node, x, y);
3725 }
3726
3727
3728
3729
3730 /* Our motion arrow is either a box (in the case of the original spot)
3731  * or an arrow.  It is expander_size wide.
3732  */
3733 /*
3734  * 11111111111111
3735  * 01111111111110
3736  * 00111111111100
3737  * 00011111111000
3738  * 00001111110000
3739  * 00000111100000
3740  * 00000111100000
3741  * 00000111100000
3742  * ~ ~ ~ ~ ~ ~ ~
3743  * 00000111100000
3744  * 00000111100000
3745  * 00000111100000
3746  * 00001111110000
3747  * 00011111111000
3748  * 00111111111100
3749  * 01111111111110
3750  * 11111111111111
3751  */
3752
3753 static void
3754 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3755 {
3756   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3757   GtkWidget *widget = GTK_WIDGET (tree_view);
3758   cairo_surface_t *mask_image;
3759   cairo_region_t *mask_region;
3760   gint x;
3761   gint y;
3762   gint width;
3763   gint height;
3764   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3765   GdkWindowAttr attributes;
3766   guint attributes_mask;
3767   cairo_t *cr;
3768
3769   if (!reorder ||
3770       reorder->left_column == tree_view->priv->drag_column ||
3771       reorder->right_column == tree_view->priv->drag_column)
3772     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3773   else if (reorder->left_column || reorder->right_column)
3774     {
3775       GtkAllocation left_allocation, right_allocation;
3776       GdkRectangle visible_rect;
3777       GtkWidget *button;
3778
3779       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3780       if (reorder->left_column)
3781         {
3782           button = gtk_tree_view_column_get_button (reorder->left_column);
3783           gtk_widget_get_allocation (button, &left_allocation);
3784           x = left_allocation.x + left_allocation.width;
3785         }
3786       else
3787         {
3788           button = gtk_tree_view_column_get_button (reorder->right_column);
3789           gtk_widget_get_allocation (button, &right_allocation);
3790           x = right_allocation.x;
3791         }
3792
3793       if (x < visible_rect.x)
3794         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3795       else if (x > visible_rect.x + visible_rect.width)
3796         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3797       else
3798         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3799     }
3800
3801   /* We want to draw the rectangle over the initial location. */
3802   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3803     {
3804       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3805         {
3806           GtkAllocation drag_allocation;
3807           GtkWidget    *button;
3808
3809           if (tree_view->priv->drag_highlight_window)
3810             {
3811               gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3812               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3813             }
3814
3815           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3816           attributes.window_type = GDK_WINDOW_CHILD;
3817           attributes.wclass = GDK_INPUT_OUTPUT;
3818           attributes.x = tree_view->priv->drag_column_x;
3819           attributes.y = 0;
3820           gtk_widget_get_allocation (button, &drag_allocation);
3821           width = attributes.width = drag_allocation.width;
3822           height = attributes.height = drag_allocation.height;
3823           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3824           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3825           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3826           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3827           gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3828
3829           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3830           cr = cairo_create (mask_image);
3831
3832           cairo_rectangle (cr, 1, 1, width - 2, height - 2);
3833           cairo_stroke (cr);
3834           cairo_destroy (cr);
3835
3836           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3837           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3838                                            mask_region, 0, 0);
3839
3840           cairo_region_destroy (mask_region);
3841           cairo_surface_destroy (mask_image);
3842
3843           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3844         }
3845     }
3846   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3847     {
3848       GtkAllocation button_allocation;
3849       GtkWidget    *button;
3850
3851       width = gtk_tree_view_get_expander_size (tree_view);
3852
3853       /* Get x, y, width, height of arrow */
3854       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3855       if (reorder->left_column)
3856         {
3857           button = gtk_tree_view_column_get_button (reorder->left_column);
3858           gtk_widget_get_allocation (button, &button_allocation);
3859           x += button_allocation.x + button_allocation.width - width/2;
3860           height = button_allocation.height;
3861         }
3862       else
3863         {
3864           button = gtk_tree_view_column_get_button (reorder->right_column);
3865           gtk_widget_get_allocation (button, &button_allocation);
3866           x += button_allocation.x - width/2;
3867           height = button_allocation.height;
3868         }
3869       y -= width/2; /* The arrow takes up only half the space */
3870       height += width;
3871
3872       /* Create the new window */
3873       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3874         {
3875           if (tree_view->priv->drag_highlight_window)
3876             {
3877               gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3878               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3879             }
3880
3881           attributes.window_type = GDK_WINDOW_TEMP;
3882           attributes.wclass = GDK_INPUT_OUTPUT;
3883           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3884           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3885           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3886           attributes.x = x;
3887           attributes.y = y;
3888           attributes.width = width;
3889           attributes.height = height;
3890           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3891                                                                    &attributes, attributes_mask);
3892           gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3893
3894           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3895
3896           cr = cairo_create (mask_image);
3897           cairo_move_to (cr, 0, 0);
3898           cairo_line_to (cr, width, 0);
3899           cairo_line_to (cr, width / 2., width / 2);
3900           cairo_move_to (cr, 0, height);
3901           cairo_line_to (cr, width, height);
3902           cairo_line_to (cr, width / 2., height - width / 2.);
3903           cairo_fill (cr);
3904           cairo_destroy (cr);
3905
3906           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3907           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3908                                            mask_region, 0, 0);
3909
3910           cairo_region_destroy (mask_region);
3911           cairo_surface_destroy (mask_image);
3912         }
3913
3914       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3915       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3916     }
3917   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3918            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3919     {
3920       GtkAllocation allocation;
3921       GtkWidget    *button;
3922       gint          expander_size;
3923
3924       expander_size = gtk_tree_view_get_expander_size (tree_view);
3925
3926       /* Get x, y, width, height of arrow */
3927       width = expander_size/2; /* remember, the arrow only takes half the available width */
3928       gdk_window_get_origin (gtk_widget_get_window (widget),
3929                              &x, &y);
3930       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3931         {
3932           gtk_widget_get_allocation (widget, &allocation);
3933           x += allocation.width - width;
3934         }
3935
3936       if (reorder->left_column)
3937         {
3938           button = gtk_tree_view_column_get_button (reorder->left_column);
3939           gtk_widget_get_allocation (button, &allocation);
3940           height = allocation.height;
3941         }
3942       else
3943         {
3944           button = gtk_tree_view_column_get_button (reorder->right_column);
3945           gtk_widget_get_allocation (button, &allocation);
3946           height = allocation.height;
3947         }
3948
3949       y -= expander_size;
3950       height += 2 * expander_size;
3951
3952       /* Create the new window */
3953       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3954           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3955         {
3956           if (tree_view->priv->drag_highlight_window)
3957             {
3958               gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3959               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3960             }
3961
3962           attributes.window_type = GDK_WINDOW_TEMP;
3963           attributes.wclass = GDK_INPUT_OUTPUT;
3964           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3965           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3966           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3967           attributes.x = x;
3968           attributes.y = y;
3969           attributes.width = width;
3970           attributes.height = height;
3971           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget), &attributes, attributes_mask);
3972           gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3973
3974           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3975
3976           cr = cairo_create (mask_image);
3977           /* mirror if we're on the left */
3978           if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3979             {
3980               cairo_translate (cr, width, 0);
3981               cairo_scale (cr, -1, 1);
3982             }
3983           cairo_move_to (cr, 0, 0);
3984           cairo_line_to (cr, width, width);
3985           cairo_line_to (cr, 0, expander_size);
3986           cairo_move_to (cr, 0, height);
3987           cairo_line_to (cr, width, height - width);
3988           cairo_line_to (cr, 0, height - expander_size);
3989           cairo_fill (cr);
3990           cairo_destroy (cr);
3991
3992           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3993           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3994                                            mask_region, 0, 0);
3995
3996           cairo_region_destroy (mask_region);
3997           cairo_surface_destroy (mask_image);
3998         }
3999
4000       tree_view->priv->drag_column_window_state = arrow_type;
4001       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
4002    }
4003   else
4004     {
4005       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
4006       gdk_window_hide (tree_view->priv->drag_highlight_window);
4007       return;
4008     }
4009
4010   gdk_window_show (tree_view->priv->drag_highlight_window);
4011   gdk_window_raise (tree_view->priv->drag_highlight_window);
4012 }
4013
4014 static gboolean
4015 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
4016                                     GdkEventMotion *event)
4017 {
4018   gint x;
4019   gint new_width;
4020   GtkTreeViewColumn *column;
4021   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4022
4023   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
4024
4025   gdk_window_get_device_position (tree_view->priv->bin_window,
4026                                   gdk_event_get_device ((GdkEvent *) event),
4027                                   &x, NULL, NULL);
4028
4029   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
4030     new_width = MAX (tree_view->priv->x_drag - x, 0);
4031   else
4032     new_width = MAX (x - tree_view->priv->x_drag, 0);
4033
4034   if (new_width != gtk_tree_view_column_get_width (column))
4035     gtk_tree_view_modify_column_width (tree_view, column, new_width);
4036
4037   return FALSE;
4038 }
4039
4040
4041 static void
4042 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view,
4043                                       GdkEvent    *event)
4044 {
4045   GtkTreeViewColumnReorder *reorder = NULL;
4046   GList *list;
4047   gint mouse_x;
4048
4049   gdk_window_get_device_position (tree_view->priv->header_window,
4050                                   gdk_event_get_device (event),
4051                                   &mouse_x, NULL, NULL);
4052   for (list = tree_view->priv->column_drag_info; list; list = list->next)
4053     {
4054       reorder = (GtkTreeViewColumnReorder *) list->data;
4055       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
4056         break;
4057       reorder = NULL;
4058     }
4059
4060   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
4061       return;*/
4062
4063   tree_view->priv->cur_reorder = reorder;
4064   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
4065 }
4066
4067 static void
4068 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
4069 {
4070   GdkRectangle visible_rect;
4071   gint y;
4072   gint offset;
4073
4074   gdk_window_get_device_position (tree_view->priv->bin_window,
4075                                   gdk_device_manager_get_client_pointer (
4076                                     gdk_display_get_device_manager (
4077                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4078                                   NULL, &y, NULL);
4079   y += tree_view->priv->dy;
4080
4081   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4082
4083   /* see if we are near the edge. */
4084   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
4085   if (offset > 0)
4086     {
4087       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
4088       if (offset < 0)
4089         return;
4090     }
4091
4092   gtk_adjustment_set_value (tree_view->priv->vadjustment,
4093                             MAX (gtk_adjustment_get_value (tree_view->priv->vadjustment) + offset, 0.0));
4094 }
4095
4096 static gboolean
4097 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view,
4098                                      GdkEvent    *event)
4099 {
4100   GdkRectangle visible_rect;
4101   gint x;
4102   gint offset;
4103
4104   gdk_window_get_device_position (tree_view->priv->bin_window,
4105                                   gdk_event_get_device (event),
4106                                   &x, NULL, NULL);
4107
4108   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4109
4110   /* See if we are near the edge. */
4111   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
4112   if (offset > 0)
4113     {
4114       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
4115       if (offset < 0)
4116         return TRUE;
4117     }
4118   offset = offset/3;
4119
4120   gtk_adjustment_set_value (tree_view->priv->hadjustment,
4121                             MAX (gtk_adjustment_get_value (tree_view->priv->hadjustment) + offset, 0.0));
4122
4123   return TRUE;
4124
4125 }
4126
4127 static gboolean
4128 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
4129                                   GdkEventMotion *event)
4130 {
4131   GtkAllocation allocation, button_allocation;
4132   GtkTreeView *tree_view = (GtkTreeView *) widget;
4133   GtkTreeViewColumn *column = tree_view->priv->drag_column;
4134   GtkWidget *button;
4135   gint x, y;
4136
4137   /* Sanity Check */
4138   if ((column == NULL) ||
4139       (event->window != tree_view->priv->drag_window))
4140     return FALSE;
4141
4142   button = gtk_tree_view_column_get_button (column);
4143
4144   /* Handle moving the header */
4145   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
4146   gtk_widget_get_allocation (widget, &allocation);
4147   gtk_widget_get_allocation (button, &button_allocation);
4148   x = CLAMP (x + (gint)event->x - _gtk_tree_view_column_get_drag_x (column), 0,
4149              MAX (tree_view->priv->width, allocation.width) - button_allocation.width);
4150   gdk_window_move (tree_view->priv->drag_window, x, y);
4151
4152   /* autoscroll, if needed */
4153   gtk_tree_view_horizontal_autoscroll (tree_view, (GdkEvent *) event);
4154   /* Update the current reorder position and arrow; */
4155   gtk_tree_view_update_current_reorder (tree_view, (GdkEvent *) event);
4156
4157   return TRUE;
4158 }
4159
4160 static void
4161 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
4162 {
4163   remove_scroll_timeout (tree_view);
4164   gtk_grab_remove (GTK_WIDGET (tree_view));
4165
4166   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4167     {
4168       GtkTreePath *tmp_path;
4169
4170       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4171
4172       /* The anchor path should be set to the start path */
4173       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_start_tree,
4174                                                  tree_view->priv->rubber_band_start_node);
4175
4176       if (tree_view->priv->anchor)
4177         gtk_tree_row_reference_free (tree_view->priv->anchor);
4178
4179       tree_view->priv->anchor =
4180         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
4181                                           tree_view->priv->model,
4182                                           tmp_path);
4183
4184       gtk_tree_path_free (tmp_path);
4185
4186       /* ... and the cursor to the end path */
4187       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_end_tree,
4188                                                  tree_view->priv->rubber_band_end_node);
4189       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, 0);
4190       gtk_tree_path_free (tmp_path);
4191
4192       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
4193     }
4194
4195   /* Clear status variables */
4196   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
4197   tree_view->priv->rubber_band_extend = FALSE;
4198   tree_view->priv->rubber_band_modify = FALSE;
4199
4200   tree_view->priv->rubber_band_start_node = NULL;
4201   tree_view->priv->rubber_band_start_tree = NULL;
4202   tree_view->priv->rubber_band_end_node = NULL;
4203   tree_view->priv->rubber_band_end_tree = NULL;
4204 }
4205
4206 static void
4207 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
4208                                                  GtkRBTree   *start_tree,
4209                                                  GtkRBNode   *start_node,
4210                                                  GtkRBTree   *end_tree,
4211                                                  GtkRBNode   *end_node,
4212                                                  gboolean     select,
4213                                                  gboolean     skip_start,
4214                                                  gboolean     skip_end)
4215 {
4216   if (start_node == end_node)
4217     return;
4218
4219   /* We skip the first node and jump inside the loop */
4220   if (skip_start)
4221     goto skip_first;
4222
4223   do
4224     {
4225       /* Small optimization by assuming insensitive nodes are never
4226        * selected.
4227        */
4228       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4229         {
4230           GtkTreePath *path;
4231           gboolean selectable;
4232
4233           path = _gtk_tree_path_new_from_rbtree (start_tree, start_node);
4234           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
4235           gtk_tree_path_free (path);
4236
4237           if (!selectable)
4238             goto node_not_selectable;
4239         }
4240
4241       if (select)
4242         {
4243           if (tree_view->priv->rubber_band_extend)
4244             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4245           else if (tree_view->priv->rubber_band_modify)
4246             {
4247               /* Toggle the selection state */
4248               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4249                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4250               else
4251                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4252             }
4253           else
4254             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4255         }
4256       else
4257         {
4258           /* Mirror the above */
4259           if (tree_view->priv->rubber_band_extend)
4260             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4261           else if (tree_view->priv->rubber_band_modify)
4262             {
4263               /* Toggle the selection state */
4264               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4265                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4266               else
4267                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4268             }
4269           else
4270             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4271         }
4272
4273       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
4274
4275 node_not_selectable:
4276       if (start_node == end_node)
4277         break;
4278
4279 skip_first:
4280
4281       if (start_node->children)
4282         {
4283           start_tree = start_node->children;
4284           start_node = _gtk_rbtree_first (start_tree);
4285         }
4286       else
4287         {
4288           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
4289
4290           if (!start_tree)
4291             /* Ran out of tree */
4292             break;
4293         }
4294
4295       if (skip_end && start_node == end_node)
4296         break;
4297     }
4298   while (TRUE);
4299 }
4300
4301 static void
4302 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
4303 {
4304   GtkRBTree *start_tree, *end_tree;
4305   GtkRBNode *start_node, *end_node;
4306
4307   _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);
4308   _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);
4309
4310   /* Handle the start area first */
4311   if (!tree_view->priv->rubber_band_start_node)
4312     {
4313       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4314                                                        start_tree,
4315                                                        start_node,
4316                                                        end_tree,
4317                                                        end_node,
4318                                                        TRUE,
4319                                                        FALSE,
4320                                                        FALSE);
4321     }
4322   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
4323            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4324     {
4325       /* New node is above the old one; selection became bigger */
4326       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4327                                                        start_tree,
4328                                                        start_node,
4329                                                        tree_view->priv->rubber_band_start_tree,
4330                                                        tree_view->priv->rubber_band_start_node,
4331                                                        TRUE,
4332                                                        FALSE,
4333                                                        TRUE);
4334     }
4335   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
4336            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4337     {
4338       /* New node is below the old one; selection became smaller */
4339       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4340                                                        tree_view->priv->rubber_band_start_tree,
4341                                                        tree_view->priv->rubber_band_start_node,
4342                                                        start_tree,
4343                                                        start_node,
4344                                                        FALSE,
4345                                                        FALSE,
4346                                                        TRUE);
4347     }
4348
4349   tree_view->priv->rubber_band_start_tree = start_tree;
4350   tree_view->priv->rubber_band_start_node = start_node;
4351
4352   /* Next, handle the end area */
4353   if (!tree_view->priv->rubber_band_end_node)
4354     {
4355       /* In the event this happens, start_node was also NULL; this case is
4356        * handled above.
4357        */
4358     }
4359   else if (!end_node)
4360     {
4361       /* Find the last node in the tree */
4362       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
4363                                &end_tree, &end_node);
4364
4365       /* Selection reached end of the tree */
4366       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4367                                                        tree_view->priv->rubber_band_end_tree,
4368                                                        tree_view->priv->rubber_band_end_node,
4369                                                        end_tree,
4370                                                        end_node,
4371                                                        TRUE,
4372                                                        TRUE,
4373                                                        FALSE);
4374     }
4375   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
4376            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4377     {
4378       /* New node is below the old one; selection became bigger */
4379       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4380                                                        tree_view->priv->rubber_band_end_tree,
4381                                                        tree_view->priv->rubber_band_end_node,
4382                                                        end_tree,
4383                                                        end_node,
4384                                                        TRUE,
4385                                                        TRUE,
4386                                                        FALSE);
4387     }
4388   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
4389            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4390     {
4391       /* New node is above the old one; selection became smaller */
4392       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4393                                                        end_tree,
4394                                                        end_node,
4395                                                        tree_view->priv->rubber_band_end_tree,
4396                                                        tree_view->priv->rubber_band_end_node,
4397                                                        FALSE,
4398                                                        TRUE,
4399                                                        FALSE);
4400     }
4401
4402   tree_view->priv->rubber_band_end_tree = end_tree;
4403   tree_view->priv->rubber_band_end_node = end_node;
4404 }
4405
4406 static void
4407 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
4408 {
4409   gint x, y;
4410   GdkRectangle old_area;
4411   GdkRectangle new_area;
4412   GdkRectangle common;
4413   cairo_region_t *invalid_region;
4414
4415   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4416   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4417   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
4418   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
4419
4420   gdk_window_get_device_position (tree_view->priv->bin_window,
4421                                   gdk_device_manager_get_client_pointer (
4422                                     gdk_display_get_device_manager (
4423                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4424                                   &x, &y, NULL);
4425
4426   x = MAX (x, 0);
4427   y = MAX (y, 0) + tree_view->priv->dy;
4428
4429   new_area.x = MIN (tree_view->priv->press_start_x, x);
4430   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
4431   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
4432   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
4433
4434   invalid_region = cairo_region_create_rectangle (&old_area);
4435   cairo_region_union_rectangle (invalid_region, &new_area);
4436
4437   gdk_rectangle_intersect (&old_area, &new_area, &common);
4438   if (common.width > 2 && common.height > 2)
4439     {
4440       cairo_region_t *common_region;
4441
4442       /* make sure the border is invalidated */
4443       common.x += 1;
4444       common.y += 1;
4445       common.width -= 2;
4446       common.height -= 2;
4447
4448       common_region = cairo_region_create_rectangle (&common);
4449
4450       cairo_region_subtract (invalid_region, common_region);
4451       cairo_region_destroy (common_region);
4452     }
4453
4454   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
4455
4456   cairo_region_destroy (invalid_region);
4457
4458   tree_view->priv->rubber_band_x = x;
4459   tree_view->priv->rubber_band_y = y;
4460
4461   gtk_tree_view_update_rubber_band_selection (tree_view);
4462 }
4463
4464 static void
4465 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4466                                  cairo_t      *cr)
4467 {
4468   GdkRectangle rect;
4469   GtkStyleContext *context;
4470
4471   cairo_save (cr);
4472
4473   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4474
4475   gtk_style_context_save (context);
4476   gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND);
4477
4478   rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4479   rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4480   rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4481   rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4482
4483   gdk_cairo_rectangle (cr, &rect);
4484   cairo_clip (cr);
4485
4486   gtk_render_background (context, cr,
4487                          rect.x, rect.y,
4488                          rect.width, rect.height);
4489   gtk_render_frame (context, cr,
4490                     rect.x, rect.y,
4491                     rect.width, rect.height);
4492
4493   gtk_style_context_restore (context);
4494   cairo_restore (cr);
4495 }
4496
4497 static gboolean
4498 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4499                                  GdkEventMotion *event)
4500 {
4501   GtkTreeView *tree_view;
4502   GtkRBTree *tree;
4503   GtkRBNode *node;
4504   gint new_y;
4505
4506   tree_view = (GtkTreeView *) widget;
4507
4508   if (tree_view->priv->tree == NULL)
4509     return FALSE;
4510
4511   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4512     {
4513       gtk_grab_add (GTK_WIDGET (tree_view));
4514       gtk_tree_view_update_rubber_band (tree_view);
4515
4516       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4517     }
4518   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4519     {
4520       gtk_tree_view_update_rubber_band (tree_view);
4521
4522       add_scroll_timeout (tree_view);
4523     }
4524
4525   /* only check for an initiated drag when a button is pressed */
4526   if (tree_view->priv->pressed_button >= 0
4527       && !tree_view->priv->rubber_band_status)
4528     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4529
4530   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4531   if (new_y < 0)
4532     new_y = 0;
4533
4534   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4535
4536   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4537   if ((tree_view->priv->button_pressed_node != NULL) &&
4538       (tree_view->priv->button_pressed_node != node))
4539     node = NULL;
4540
4541   tree_view->priv->event_last_x = event->x;
4542   tree_view->priv->event_last_y = event->y;
4543
4544   prelight_or_select (tree_view, tree, node, event->x, event->y);
4545
4546   return TRUE;
4547 }
4548
4549 static gboolean
4550 gtk_tree_view_motion (GtkWidget      *widget,
4551                       GdkEventMotion *event)
4552 {
4553   GtkTreeView *tree_view;
4554
4555   tree_view = (GtkTreeView *) widget;
4556
4557   /* Resizing a column */
4558   if (tree_view->priv->in_column_resize)
4559     return gtk_tree_view_motion_resize_column (widget, event);
4560
4561   /* Drag column */
4562   if (tree_view->priv->in_column_drag)
4563     return gtk_tree_view_motion_drag_column (widget, event);
4564
4565   /* Sanity check it */
4566   if (event->window == tree_view->priv->bin_window)
4567     return gtk_tree_view_motion_bin_window (widget, event);
4568
4569   return FALSE;
4570 }
4571
4572 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4573  * the tree is empty.
4574  */
4575 static void
4576 invalidate_empty_focus (GtkTreeView *tree_view)
4577 {
4578   GdkRectangle area;
4579
4580   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
4581     return;
4582
4583   area.x = 0;
4584   area.y = 0;
4585   area.width = gdk_window_get_width (tree_view->priv->bin_window);
4586   area.height = gdk_window_get_height (tree_view->priv->bin_window);
4587   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4588 }
4589
4590 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4591  * is empty.
4592  */
4593 static void
4594 draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr)
4595 {
4596   GtkWidget *widget = GTK_WIDGET (tree_view);
4597   gint w, h;
4598
4599   if (!gtk_widget_has_visible_focus (widget))
4600     return;
4601
4602   w = gdk_window_get_width (tree_view->priv->bin_window) - 2;
4603   h = gdk_window_get_height (tree_view->priv->bin_window) - 2;
4604
4605   if (w > 0 && h > 0)
4606     {
4607       GtkStyleContext *context;
4608
4609       context = gtk_widget_get_style_context (widget);
4610
4611       gtk_render_focus (context, cr, 1, 1, w, h);
4612     }
4613 }
4614
4615 typedef enum {
4616   GTK_TREE_VIEW_GRID_LINE,
4617   GTK_TREE_VIEW_TREE_LINE,
4618   GTK_TREE_VIEW_FOREGROUND_LINE
4619 } GtkTreeViewLineType;
4620
4621 static void
4622 gtk_tree_view_draw_line (GtkTreeView         *tree_view,
4623                          cairo_t             *cr,
4624                          GtkTreeViewLineType  type,
4625                          int                  x1,
4626                          int                  y1,
4627                          int                  x2,
4628                          int                  y2)
4629 {
4630   cairo_save (cr);
4631
4632   switch (type)
4633     {
4634     case GTK_TREE_VIEW_TREE_LINE:
4635       cairo_set_source_rgb (cr, 0, 0, 0);
4636       cairo_set_line_width (cr, tree_view->priv->tree_line_width);
4637       if (tree_view->priv->tree_line_dashes[0])
4638         cairo_set_dash (cr,
4639                         tree_view->priv->tree_line_dashes,
4640                         2, 0.5);
4641       break;
4642     case GTK_TREE_VIEW_GRID_LINE:
4643       cairo_set_source_rgb (cr, 0, 0, 0);
4644       cairo_set_line_width (cr, tree_view->priv->grid_line_width);
4645       if (tree_view->priv->grid_line_dashes[0])
4646         cairo_set_dash (cr,
4647                         tree_view->priv->grid_line_dashes,
4648                         2, 0.5);
4649       break;
4650     default:
4651       g_assert_not_reached ();
4652       /* fall through */
4653     case GTK_TREE_VIEW_FOREGROUND_LINE:
4654       {
4655         GtkStyleContext *context;
4656         GtkStateFlags state;
4657         GdkRGBA color;
4658
4659         context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4660         state = gtk_widget_get_state_flags (GTK_WIDGET (tree_view));
4661
4662         cairo_set_line_width (cr, 1.0);
4663         gtk_style_context_get_color (context, state, &color);
4664         gdk_cairo_set_source_rgba (cr, &color);
4665       }
4666
4667       break;
4668     }
4669
4670   cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
4671   cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
4672   cairo_stroke (cr);
4673
4674   cairo_restore (cr);
4675 }
4676
4677 static void
4678 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4679                                cairo_t        *cr,
4680                                gint            n_visible_columns)
4681 {
4682   GList *list = tree_view->priv->columns;
4683   gint i = 0;
4684   gint current_x = 0;
4685
4686   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4687       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4688     return;
4689
4690   /* Only draw the lines for visible rows and columns */
4691   for (list = tree_view->priv->columns; list; list = list->next, i++)
4692     {
4693       GtkTreeViewColumn *column = list->data;
4694
4695       /* We don't want a line for the last column */
4696       if (i == n_visible_columns - 1)
4697         break;
4698
4699       if (!gtk_tree_view_column_get_visible (column))
4700         continue;
4701
4702       current_x += gtk_tree_view_column_get_width (column);
4703
4704       gtk_tree_view_draw_line (tree_view, cr,
4705                                GTK_TREE_VIEW_GRID_LINE,
4706                                current_x - 1, 0,
4707                                current_x - 1, tree_view->priv->height);
4708     }
4709 }
4710
4711 /* Warning: Very scary function.
4712  * Modify at your own risk
4713  *
4714  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4715  * FIXME: It's not...
4716  */
4717 static gboolean
4718 gtk_tree_view_bin_draw (GtkWidget      *widget,
4719                         cairo_t        *cr)
4720 {
4721   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4722   GtkTreePath *path;
4723   GtkRBTree *tree;
4724   GList *list;
4725   GtkRBNode *node;
4726   GtkRBNode *drag_highlight = NULL;
4727   GtkRBTree *drag_highlight_tree = NULL;
4728   GtkTreeIter iter;
4729   gint new_y;
4730   gint y_offset, cell_offset;
4731   gint max_height;
4732   gint depth;
4733   GdkRectangle background_area;
4734   GdkRectangle cell_area;
4735   GdkRectangle clip;
4736   guint flags;
4737   gint highlight_x;
4738   gint expander_cell_width;
4739   gint bin_window_width;
4740   gint bin_window_height;
4741   GtkTreePath *drag_dest_path;
4742   GList *first_column, *last_column;
4743   gint vertical_separator;
4744   gint horizontal_separator;
4745   gboolean allow_rules;
4746   gboolean has_can_focus_cell;
4747   gboolean rtl;
4748   gint n_visible_columns;
4749   gint grid_line_width;
4750   gint expander_size;
4751   gboolean draw_vgrid_lines, draw_hgrid_lines;
4752   GtkStyleContext *context;
4753   gboolean parity;
4754
4755   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4756   context = gtk_widget_get_style_context (widget);
4757
4758   gtk_widget_style_get (widget,
4759                         "horizontal-separator", &horizontal_separator,
4760                         "vertical-separator", &vertical_separator,
4761                         "allow-rules", &allow_rules,
4762                         NULL);
4763
4764   if (tree_view->priv->tree == NULL)
4765     {
4766       draw_empty_focus (tree_view, cr);
4767       return TRUE;
4768     }
4769
4770   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
4771   bin_window_height = gdk_window_get_height (tree_view->priv->bin_window);
4772   cairo_rectangle (cr, 0, 0, bin_window_width, bin_window_height);
4773   cairo_clip (cr);
4774   if (!gdk_cairo_get_clip_rectangle (cr, &clip))
4775     return TRUE;
4776
4777   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, clip.y);
4778
4779   if (new_y < 0)
4780     new_y = 0;
4781   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4782
4783   if (tree_view->priv->height < bin_window_height)
4784     {
4785       gtk_style_context_save (context);
4786       gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4787
4788       gtk_render_background (context, cr,
4789                              0, tree_view->priv->height,
4790                              bin_window_width,
4791                              bin_window_height - tree_view->priv->height);
4792
4793       gtk_style_context_restore (context);
4794     }
4795
4796   if (node == NULL)
4797     return TRUE;
4798
4799   /* find the path for the node */
4800   path = _gtk_tree_path_new_from_rbtree (tree, node);
4801   gtk_tree_model_get_iter (tree_view->priv->model,
4802                            &iter,
4803                            path);
4804   depth = gtk_tree_path_get_depth (path);
4805   gtk_tree_path_free (path);
4806
4807   drag_dest_path = NULL;
4808
4809   if (tree_view->priv->drag_dest_row)
4810     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4811
4812   if (drag_dest_path)
4813     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4814                               &drag_highlight_tree, &drag_highlight);
4815
4816   draw_vgrid_lines =
4817     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4818     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4819   draw_hgrid_lines =
4820     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4821     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4822   expander_size = gtk_tree_view_get_expander_size (tree_view);
4823
4824   if (draw_vgrid_lines || draw_hgrid_lines)
4825     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4826
4827   n_visible_columns = 0;
4828   for (list = tree_view->priv->columns; list; list = list->next)
4829     {
4830       if (!gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
4831         continue;
4832       n_visible_columns ++;
4833     }
4834
4835   /* Find the last column */
4836   for (last_column = g_list_last (tree_view->priv->columns);
4837        last_column &&
4838        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
4839        last_column = last_column->prev)
4840     ;
4841
4842   /* and the first */
4843   for (first_column = g_list_first (tree_view->priv->columns);
4844        first_column &&
4845        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
4846        first_column = first_column->next)
4847     ;
4848
4849   /* Actually process the expose event.  To do this, we want to
4850    * start at the first node of the event, and walk the tree in
4851    * order, drawing each successive node.
4852    */
4853
4854   parity = !(_gtk_rbtree_node_get_index (tree, node) % 2);
4855
4856   do
4857     {
4858       gboolean is_separator = FALSE;
4859       gboolean is_first = FALSE;
4860       gboolean is_last = FALSE;
4861       gint n_col = 0;
4862
4863       parity = !parity;
4864       is_separator = row_is_separator (tree_view, &iter, NULL);
4865
4866       max_height = gtk_tree_view_get_row_height (tree_view, node);
4867
4868       cell_offset = 0;
4869       highlight_x = 0; /* should match x coord of first cell */
4870       expander_cell_width = 0;
4871
4872       background_area.y = y_offset + clip.y;
4873       background_area.height = max_height;
4874
4875       flags = 0;
4876
4877       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4878         flags |= GTK_CELL_RENDERER_PRELIT;
4879
4880       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4881         flags |= GTK_CELL_RENDERER_SELECTED;
4882
4883       /* we *need* to set cell data on all cells before the call
4884        * to _has_can_focus_cell, else _has_can_focus_cell() does not
4885        * return a correct value.
4886        */
4887       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4888            list;
4889            list = (rtl ? list->prev : list->next))
4890         {
4891           GtkTreeViewColumn *column = list->data;
4892           gtk_tree_view_column_cell_set_cell_data (column,
4893                                                    tree_view->priv->model,
4894                                                    &iter,
4895                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4896                                                    node->children?TRUE:FALSE);
4897         }
4898
4899       has_can_focus_cell = gtk_tree_view_has_can_focus_cell (tree_view);
4900
4901       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4902            list;
4903            list = (rtl ? list->prev : list->next))
4904         {
4905           GtkTreeViewColumn *column = list->data;
4906           GtkRegionFlags row_flags = 0, column_flags = 0;
4907           GtkStateFlags state = 0;
4908           gint width;
4909           gboolean draw_focus;
4910
4911           if (!gtk_tree_view_column_get_visible (column))
4912             continue;
4913
4914           n_col++;
4915           width = gtk_tree_view_column_get_width (column);
4916
4917           if (cell_offset > clip.x + clip.width ||
4918               cell_offset + width < clip.x)
4919             {
4920               cell_offset += width;
4921               continue;
4922             }
4923
4924           if (gtk_tree_view_column_get_sort_indicator (column))
4925             flags |= GTK_CELL_RENDERER_SORTED;
4926           else
4927             flags &= ~GTK_CELL_RENDERER_SORTED;
4928
4929           if (tree_view->priv->cursor_node == node)
4930             flags |= GTK_CELL_RENDERER_FOCUSED;
4931           else
4932             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4933
4934           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
4935             flags |= GTK_CELL_RENDERER_EXPANDABLE;
4936           else
4937             flags &= ~GTK_CELL_RENDERER_EXPANDABLE;
4938
4939           if (node->children)
4940             flags |= GTK_CELL_RENDERER_EXPANDED;
4941           else
4942             flags &= ~GTK_CELL_RENDERER_EXPANDED;
4943
4944           background_area.x = cell_offset;
4945           background_area.width = width;
4946
4947           cell_area = background_area;
4948           cell_area.y += vertical_separator / 2;
4949           cell_area.x += horizontal_separator / 2;
4950           cell_area.height -= vertical_separator;
4951           cell_area.width -= horizontal_separator;
4952
4953           if (draw_vgrid_lines)
4954             {
4955               if (list == first_column)
4956                 {
4957                   cell_area.width -= grid_line_width / 2;
4958                 }
4959               else if (list == last_column)
4960                 {
4961                   cell_area.x += grid_line_width / 2;
4962                   cell_area.width -= grid_line_width / 2;
4963                 }
4964               else
4965                 {
4966                   cell_area.x += grid_line_width / 2;
4967                   cell_area.width -= grid_line_width;
4968                 }
4969             }
4970
4971           if (draw_hgrid_lines)
4972             {
4973               cell_area.y += grid_line_width / 2;
4974               cell_area.height -= grid_line_width;
4975             }
4976
4977           if (!gdk_rectangle_intersect (&clip, &background_area, NULL))
4978             {
4979               cell_offset += gtk_tree_view_column_get_width (column);
4980               continue;
4981             }
4982
4983           gtk_tree_view_column_cell_set_cell_data (column,
4984                                                    tree_view->priv->model,
4985                                                    &iter,
4986                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4987                                                    node->children?TRUE:FALSE);
4988
4989           /* Select the detail for drawing the cell.  relevant
4990            * factors are parity, sortedness, and whether to
4991            * display rules.
4992            */
4993           if (allow_rules && tree_view->priv->has_rules)
4994             {
4995               if (parity)
4996                 row_flags |= GTK_REGION_ODD;
4997               else
4998                 row_flags |= GTK_REGION_EVEN;
4999             }
5000
5001           if ((flags & GTK_CELL_RENDERER_SORTED) &&
5002               n_visible_columns >= 3)
5003             column_flags |= GTK_REGION_SORTED;
5004
5005           is_first = (rtl ? !list->next : !list->prev);
5006           is_last = (rtl ? !list->prev : !list->next);
5007
5008           if (is_first)
5009             column_flags |= GTK_REGION_FIRST;
5010
5011           if (is_last)
5012             column_flags |= GTK_REGION_LAST;
5013
5014           if ((n_col % 2) == 0)
5015             column_flags |= GTK_REGION_EVEN;
5016           else
5017             column_flags |= GTK_REGION_ODD;
5018
5019           gtk_style_context_save (context);
5020
5021           state = gtk_cell_renderer_get_state (NULL, widget, flags);
5022           gtk_style_context_set_state (context, state);
5023
5024           gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
5025           gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
5026           gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, column_flags);
5027
5028           if (node == tree_view->priv->cursor_node && has_can_focus_cell
5029               && ((column == tree_view->priv->focus_column
5030                    && tree_view->priv->draw_keyfocus &&
5031                    gtk_widget_has_visible_focus (widget))
5032                   || (column == tree_view->priv->edited_column)))
5033             draw_focus = TRUE;
5034           else
5035             draw_focus = FALSE;
5036
5037           /* Draw background */
5038           gtk_render_background (context, cr,
5039                                  background_area.x,
5040                                  background_area.y,
5041                                  background_area.width,
5042                                  background_area.height);
5043
5044           /* Draw frame */
5045           gtk_render_frame (context, cr,
5046                             background_area.x,
5047                             background_area.y,
5048                             background_area.width,
5049                             background_area.height);
5050
5051           if (gtk_tree_view_is_expander_column (tree_view, column))
5052             {
5053               if (!rtl)
5054                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
5055               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
5056
5057               if (gtk_tree_view_draw_expanders (tree_view))
5058                 {
5059                   int expander_size = gtk_tree_view_get_expander_size (tree_view);
5060                   if (!rtl)
5061                     cell_area.x += depth * expander_size;
5062                   cell_area.width -= depth * expander_size;
5063                 }
5064
5065               /* If we have an expander column, the highlight underline
5066                * starts with that column, so that it indicates which
5067                * level of the tree we're dropping at.
5068                */
5069               highlight_x = cell_area.x;
5070               expander_cell_width = cell_area.width;
5071
5072               if (is_separator)
5073                 {
5074                   gtk_style_context_save (context);
5075                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5076
5077                   gtk_render_line (context, cr,
5078                                    cell_area.x,
5079                                    cell_area.y + cell_area.height / 2,
5080                                    cell_area.x + cell_area.width,
5081                                    cell_area.y + cell_area.height / 2);
5082
5083                   gtk_style_context_restore (context);
5084                 }
5085               else
5086                 {
5087                   _gtk_tree_view_column_cell_render (column,
5088                                                      cr,
5089                                                      &background_area,
5090                                                      &cell_area,
5091                                                      flags,
5092                                                      draw_focus);
5093                 }
5094
5095               if (gtk_tree_view_draw_expanders (tree_view)
5096                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
5097                 {
5098                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
5099                                             cr,
5100                                             tree,
5101                                             node);
5102                 }
5103             }
5104           else
5105             {
5106               if (is_separator)
5107                 {
5108                   gtk_style_context_save (context);
5109                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5110
5111                   gtk_render_line (context, cr,
5112                                    cell_area.x,
5113                                    cell_area.y + cell_area.height / 2,
5114                                    cell_area.x + cell_area.width,
5115                                    cell_area.y + cell_area.height / 2);
5116
5117                   gtk_style_context_restore (context);
5118                 }
5119               else
5120                 _gtk_tree_view_column_cell_render (column,
5121                                                    cr,
5122                                                    &background_area,
5123                                                    &cell_area,
5124                                                    flags,
5125                                                    draw_focus);
5126             }
5127
5128           if (draw_hgrid_lines)
5129             {
5130               if (background_area.y > 0)
5131                 gtk_tree_view_draw_line (tree_view, cr,
5132                                          GTK_TREE_VIEW_GRID_LINE,
5133                                          background_area.x, background_area.y,
5134                                          background_area.x + background_area.width,
5135                                          background_area.y);
5136
5137               if (y_offset + max_height >= clip.height)
5138                 gtk_tree_view_draw_line (tree_view, cr,
5139                                          GTK_TREE_VIEW_GRID_LINE,
5140                                          background_area.x, background_area.y + max_height,
5141                                          background_area.x + background_area.width,
5142                                          background_area.y + max_height);
5143             }
5144
5145           if (gtk_tree_view_is_expander_column (tree_view, column) &&
5146               tree_view->priv->tree_lines_enabled)
5147             {
5148               gint x = background_area.x;
5149               gint mult = rtl ? -1 : 1;
5150               gint y0 = background_area.y;
5151               gint y1 = background_area.y + background_area.height/2;
5152               gint y2 = background_area.y + background_area.height;
5153
5154               if (rtl)
5155                 x += background_area.width - 1;
5156
5157               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
5158                   && depth > 1)
5159                 {
5160                   gtk_tree_view_draw_line (tree_view, cr,
5161                                            GTK_TREE_VIEW_TREE_LINE,
5162                                            x + expander_size * (depth - 1.5) * mult,
5163                                            y1,
5164                                            x + expander_size * (depth - 1.1) * mult,
5165                                            y1);
5166                 }
5167               else if (depth > 1)
5168                 {
5169                   gtk_tree_view_draw_line (tree_view, cr,
5170                                            GTK_TREE_VIEW_TREE_LINE,
5171                                            x + expander_size * (depth - 1.5) * mult,
5172                                            y1,
5173                                            x + expander_size * (depth - 0.5) * mult,
5174                                            y1);
5175                 }
5176
5177               if (depth > 1)
5178                 {
5179                   gint i;
5180                   GtkRBNode *tmp_node;
5181                   GtkRBTree *tmp_tree;
5182
5183                   if (!_gtk_rbtree_next (tree, node))
5184                     gtk_tree_view_draw_line (tree_view, cr,
5185                                              GTK_TREE_VIEW_TREE_LINE,
5186                                              x + expander_size * (depth - 1.5) * mult,
5187                                              y0,
5188                                              x + expander_size * (depth - 1.5) * mult,
5189                                              y1);
5190                   else
5191                     gtk_tree_view_draw_line (tree_view, cr,
5192                                              GTK_TREE_VIEW_TREE_LINE,
5193                                              x + expander_size * (depth - 1.5) * mult,
5194                                              y0,
5195                                              x + expander_size * (depth - 1.5) * mult,
5196                                              y2);
5197
5198                   tmp_node = tree->parent_node;
5199                   tmp_tree = tree->parent_tree;
5200
5201                   for (i = depth - 2; i > 0; i--)
5202                     {
5203                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
5204                         gtk_tree_view_draw_line (tree_view, cr,
5205                                                  GTK_TREE_VIEW_TREE_LINE,
5206                                                  x + expander_size * (i - 0.5) * mult,
5207                                                  y0,
5208                                                  x + expander_size * (i - 0.5) * mult,
5209                                                  y2);
5210
5211                       tmp_node = tmp_tree->parent_node;
5212                       tmp_tree = tmp_tree->parent_tree;
5213                     }
5214                 }
5215             }
5216
5217           gtk_style_context_restore (context);
5218           cell_offset += gtk_tree_view_column_get_width (column);
5219         }
5220
5221       if (node == drag_highlight)
5222         {
5223           /* Draw indicator for the drop
5224            */
5225           gint highlight_y = -1;
5226           GtkRBTree *tree = NULL;
5227           GtkRBNode *node = NULL;
5228
5229           gtk_style_context_save (context);
5230           gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND);
5231
5232           switch (tree_view->priv->drag_dest_pos)
5233             {
5234             case GTK_TREE_VIEW_DROP_BEFORE:
5235               highlight_y = background_area.y - 1;
5236               if (highlight_y < 0)
5237                       highlight_y = 0;
5238               break;
5239
5240             case GTK_TREE_VIEW_DROP_AFTER:
5241               highlight_y = background_area.y + background_area.height - 1;
5242               break;
5243
5244             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
5245             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
5246               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
5247
5248               if (tree == NULL)
5249                 break;
5250
5251               gtk_render_frame (context, cr,
5252                                 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node),
5253                                 gdk_window_get_width (tree_view->priv->bin_window),
5254                                 gtk_tree_view_get_row_height (tree_view, node));
5255               break;
5256             }
5257
5258           if (highlight_y >= 0)
5259             {
5260               gtk_tree_view_draw_line (tree_view, cr,
5261                                        GTK_TREE_VIEW_FOREGROUND_LINE,
5262                                        rtl ? highlight_x + expander_cell_width : highlight_x,
5263                                        highlight_y,
5264                                        rtl ? 0 : bin_window_width,
5265                                        highlight_y);
5266             }
5267
5268           gtk_style_context_restore (context);
5269         }
5270
5271       /* draw the big row-spanning focus rectangle, if needed */
5272       if (!has_can_focus_cell && node == tree_view->priv->cursor_node &&
5273           tree_view->priv->draw_keyfocus &&
5274           gtk_widget_has_visible_focus (widget))
5275         {
5276           gint tmp_y, tmp_height;
5277           GtkStateFlags focus_rect_state = 0;
5278
5279           gtk_style_context_save (context);
5280
5281           focus_rect_state = gtk_cell_renderer_get_state (NULL, widget, flags);
5282           gtk_style_context_set_state (context, focus_rect_state);
5283
5284           if (draw_hgrid_lines)
5285             {
5286               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node) + grid_line_width / 2;
5287               tmp_height = gtk_tree_view_get_row_height (tree_view, node) - grid_line_width;
5288             }
5289           else
5290             {
5291               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
5292               tmp_height = gtk_tree_view_get_row_height (tree_view, node);
5293             }
5294
5295           gtk_render_focus (context, cr,
5296                             0, tmp_y,
5297                             gdk_window_get_width (tree_view->priv->bin_window),
5298                             tmp_height);
5299
5300           gtk_style_context_restore (context);
5301         }
5302
5303       y_offset += max_height;
5304       if (node->children)
5305         {
5306           GtkTreeIter parent = iter;
5307           gboolean has_child;
5308
5309           tree = node->children;
5310           node = _gtk_rbtree_first (tree);
5311
5312           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
5313                                                     &iter,
5314                                                     &parent);
5315           depth++;
5316
5317           /* Sanity Check! */
5318           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
5319         }
5320       else
5321         {
5322           gboolean done = FALSE;
5323
5324           do
5325             {
5326               node = _gtk_rbtree_next (tree, node);
5327               if (node != NULL)
5328                 {
5329                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
5330                   done = TRUE;
5331
5332                   /* Sanity Check! */
5333                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
5334                 }
5335               else
5336                 {
5337                   GtkTreeIter parent_iter = iter;
5338                   gboolean has_parent;
5339
5340                   node = tree->parent_node;
5341                   tree = tree->parent_tree;
5342                   if (tree == NULL)
5343                     /* we should go to done to free some memory */
5344                     goto done;
5345                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
5346                                                            &iter,
5347                                                            &parent_iter);
5348                   depth--;
5349
5350                   /* Sanity check */
5351                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
5352                 }
5353             }
5354           while (!done);
5355         }
5356     }
5357   while (y_offset < clip.height);
5358
5359 done:
5360   gtk_tree_view_draw_grid_lines (tree_view, cr, n_visible_columns);
5361
5362   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
5363     gtk_tree_view_paint_rubber_band (tree_view, cr);
5364
5365   if (drag_dest_path)
5366     gtk_tree_path_free (drag_dest_path);
5367
5368   return FALSE;
5369 }
5370
5371 static gboolean
5372 gtk_tree_view_draw (GtkWidget *widget,
5373                     cairo_t   *cr)
5374 {
5375   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5376   GtkWidget   *button;
5377   GtkStyleContext *context;
5378
5379   context = gtk_widget_get_style_context (widget);
5380   gtk_render_background (context, cr,
5381                          0, 0,
5382                          gtk_widget_get_allocated_width (widget),
5383                          gtk_widget_get_allocated_height (widget));
5384
5385   if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
5386     {
5387       GList *tmp_list;
5388
5389       cairo_save (cr);
5390
5391       gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
5392       gtk_tree_view_bin_draw (widget, cr);
5393
5394       cairo_restore (cr);
5395
5396       /* We can't just chain up to Container::draw as it will try to send the
5397        * event to the headers, so we handle propagating it to our children
5398        * (eg. widgets being edited) ourselves.
5399        */
5400       tmp_list = tree_view->priv->children;
5401       while (tmp_list)
5402         {
5403           GtkTreeViewChild *child = tmp_list->data;
5404           tmp_list = tmp_list->next;
5405
5406           gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
5407         }
5408     }
5409
5410   gtk_style_context_save (context);
5411   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_VIEW);
5412
5413   if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
5414     {
5415       GList *list;
5416
5417       for (list = tree_view->priv->columns; list != NULL; list = list->next)
5418         {
5419           GtkTreeViewColumn *column = list->data;
5420
5421           if (column == tree_view->priv->drag_column)
5422             continue;
5423
5424           if (gtk_tree_view_column_get_visible (column))
5425             {
5426               button = gtk_tree_view_column_get_button (column);
5427               gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5428                                             button, cr);
5429             }
5430         }
5431     }
5432
5433   if (tree_view->priv->drag_window &&
5434       gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
5435     {
5436       button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
5437       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5438                                     button, cr);
5439     }
5440
5441   gtk_style_context_restore (context);
5442
5443   return FALSE;
5444 }
5445
5446 enum
5447 {
5448   DROP_HOME,
5449   DROP_RIGHT,
5450   DROP_LEFT,
5451   DROP_END
5452 };
5453
5454 /* returns 0x1 when no column has been found -- yes it's hackish */
5455 static GtkTreeViewColumn *
5456 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5457                                GtkTreeViewColumn *column,
5458                                gint               drop_position)
5459 {
5460   GtkTreeViewColumn *left_column = NULL;
5461   GtkTreeViewColumn *cur_column = NULL;
5462   GList *tmp_list;
5463
5464   if (!gtk_tree_view_column_get_reorderable (column))
5465     return (GtkTreeViewColumn *)0x1;
5466
5467   switch (drop_position)
5468     {
5469       case DROP_HOME:
5470         /* find first column where we can drop */
5471         tmp_list = tree_view->priv->columns;
5472         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5473           return (GtkTreeViewColumn *)0x1;
5474
5475         while (tmp_list)
5476           {
5477             g_assert (tmp_list);
5478
5479             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5480             tmp_list = tmp_list->next;
5481
5482             if (left_column &&
5483                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5484               continue;
5485
5486             if (!tree_view->priv->column_drop_func)
5487               return left_column;
5488
5489             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5490               {
5491                 left_column = cur_column;
5492                 continue;
5493               }
5494
5495             return left_column;
5496           }
5497
5498         if (!tree_view->priv->column_drop_func)
5499           return left_column;
5500
5501         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5502           return left_column;
5503         else
5504           return (GtkTreeViewColumn *)0x1;
5505         break;
5506
5507       case DROP_RIGHT:
5508         /* find first column after column where we can drop */
5509         tmp_list = tree_view->priv->columns;
5510
5511         for (; tmp_list; tmp_list = tmp_list->next)
5512           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5513             break;
5514
5515         if (!tmp_list || !tmp_list->next)
5516           return (GtkTreeViewColumn *)0x1;
5517
5518         tmp_list = tmp_list->next;
5519         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5520         tmp_list = tmp_list->next;
5521
5522         while (tmp_list)
5523           {
5524             g_assert (tmp_list);
5525
5526             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5527             tmp_list = tmp_list->next;
5528
5529             if (left_column &&
5530                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5531               {
5532                 left_column = cur_column;
5533                 if (tmp_list)
5534                   tmp_list = tmp_list->next;
5535                 continue;
5536               }
5537
5538             if (!tree_view->priv->column_drop_func)
5539               return left_column;
5540
5541             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5542               {
5543                 left_column = cur_column;
5544                 continue;
5545               }
5546
5547             return left_column;
5548           }
5549
5550         if (!tree_view->priv->column_drop_func)
5551           return left_column;
5552
5553         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5554           return left_column;
5555         else
5556           return (GtkTreeViewColumn *)0x1;
5557         break;
5558
5559       case DROP_LEFT:
5560         /* find first column before column where we can drop */
5561         tmp_list = tree_view->priv->columns;
5562
5563         for (; tmp_list; tmp_list = tmp_list->next)
5564           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5565             break;
5566
5567         if (!tmp_list || !tmp_list->prev)
5568           return (GtkTreeViewColumn *)0x1;
5569
5570         tmp_list = tmp_list->prev;
5571         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5572         tmp_list = tmp_list->prev;
5573
5574         while (tmp_list)
5575           {
5576             g_assert (tmp_list);
5577
5578             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5579
5580             if (left_column &&
5581                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5582               {
5583                 /*if (!tmp_list->prev)
5584                   return (GtkTreeViewColumn *)0x1;
5585                   */
5586 /*
5587                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5588                 tmp_list = tmp_list->prev->prev;
5589                 continue;*/
5590
5591                 cur_column = left_column;
5592                 if (tmp_list)
5593                   tmp_list = tmp_list->prev;
5594                 continue;
5595               }
5596
5597             if (!tree_view->priv->column_drop_func)
5598               return left_column;
5599
5600             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5601               return left_column;
5602
5603             cur_column = left_column;
5604             tmp_list = tmp_list->prev;
5605           }
5606
5607         if (!tree_view->priv->column_drop_func)
5608           return NULL;
5609
5610         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5611           return NULL;
5612         else
5613           return (GtkTreeViewColumn *)0x1;
5614         break;
5615
5616       case DROP_END:
5617         /* same as DROP_HOME case, but doing it backwards */
5618         tmp_list = g_list_last (tree_view->priv->columns);
5619         cur_column = NULL;
5620
5621         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5622           return (GtkTreeViewColumn *)0x1;
5623
5624         while (tmp_list)
5625           {
5626             g_assert (tmp_list);
5627
5628             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5629
5630             if (left_column &&
5631                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5632               {
5633                 cur_column = left_column;
5634                 tmp_list = tmp_list->prev;
5635               }
5636
5637             if (!tree_view->priv->column_drop_func)
5638               return left_column;
5639
5640             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5641               return left_column;
5642
5643             cur_column = left_column;
5644             tmp_list = tmp_list->prev;
5645           }
5646
5647         if (!tree_view->priv->column_drop_func)
5648           return NULL;
5649
5650         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5651           return NULL;
5652         else
5653           return (GtkTreeViewColumn *)0x1;
5654         break;
5655     }
5656
5657   return (GtkTreeViewColumn *)0x1;
5658 }
5659
5660 static gboolean
5661 gtk_tree_view_key_press (GtkWidget   *widget,
5662                          GdkEventKey *event)
5663 {
5664   GtkTreeView *tree_view = (GtkTreeView *) widget;
5665   GtkWidget   *button;
5666
5667   if (tree_view->priv->rubber_band_status)
5668     {
5669       if (event->keyval == GDK_KEY_Escape)
5670         gtk_tree_view_stop_rubber_band (tree_view);
5671
5672       return TRUE;
5673     }
5674
5675   if (tree_view->priv->in_column_drag)
5676     {
5677       if (event->keyval == GDK_KEY_Escape)
5678         {
5679           tree_view->priv->cur_reorder = NULL;
5680           gtk_tree_view_button_release_drag_column (widget, NULL);
5681         }
5682       return TRUE;
5683     }
5684
5685   if (tree_view->priv->headers_visible)
5686     {
5687       GList *focus_column;
5688       gboolean rtl;
5689
5690       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5691
5692       for (focus_column = tree_view->priv->columns;
5693            focus_column;
5694            focus_column = focus_column->next)
5695         {
5696           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5697
5698           button = gtk_tree_view_column_get_button (column);
5699           if (gtk_widget_has_focus (button))
5700             break;
5701         }
5702
5703       if (focus_column &&
5704           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5705           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5706            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right))
5707         {
5708           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5709           gint column_width;
5710
5711           if (!gtk_tree_view_column_get_resizable (column))
5712             {
5713               gtk_widget_error_bell (widget);
5714               return TRUE;
5715             }
5716
5717           column_width = gtk_tree_view_column_get_width (column);
5718
5719           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5720               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5721             {
5722               column_width = MAX (column_width - 2, 0);
5723             }
5724           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5725                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5726             {
5727               column_width = column_width + 2;
5728             }
5729
5730           gtk_tree_view_modify_column_width (tree_view, column, column_width);
5731           return TRUE;
5732         }
5733
5734       if (focus_column &&
5735           (event->state & GDK_MOD1_MASK) &&
5736           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5737            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right
5738            || event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home
5739            || event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End))
5740         {
5741           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5742
5743           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5744               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5745             {
5746               GtkTreeViewColumn *col;
5747               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5748               if (col != (GtkTreeViewColumn *)0x1)
5749                 gtk_tree_view_move_column_after (tree_view, column, col);
5750               else
5751                 gtk_widget_error_bell (widget);
5752             }
5753           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5754                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5755             {
5756               GtkTreeViewColumn *col;
5757               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5758               if (col != (GtkTreeViewColumn *)0x1)
5759                 gtk_tree_view_move_column_after (tree_view, column, col);
5760               else
5761                 gtk_widget_error_bell (widget);
5762             }
5763           else if (event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home)
5764             {
5765               GtkTreeViewColumn *col;
5766               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5767               if (col != (GtkTreeViewColumn *)0x1)
5768                 gtk_tree_view_move_column_after (tree_view, column, col);
5769               else
5770                 gtk_widget_error_bell (widget);
5771             }
5772           else if (event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
5773             {
5774               GtkTreeViewColumn *col;
5775               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
5776               if (col != (GtkTreeViewColumn *)0x1)
5777                 gtk_tree_view_move_column_after (tree_view, column, col);
5778               else
5779                 gtk_widget_error_bell (widget);
5780             }
5781
5782           return TRUE;
5783         }
5784     }
5785
5786   /* Chain up to the parent class.  It handles the keybindings. */
5787   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5788     return TRUE;
5789
5790   if (tree_view->priv->search_entry_avoid_unhandled_binding)
5791     {
5792       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
5793       return FALSE;
5794     }
5795
5796   /* We pass the event to the search_entry.  If its text changes, then we start
5797    * the typeahead find capabilities. */
5798   if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
5799       && tree_view->priv->enable_search
5800       && !tree_view->priv->search_custom_entry_set)
5801     {
5802       GdkEvent *new_event;
5803       char *old_text;
5804       const char *new_text;
5805       gboolean retval;
5806       GdkScreen *screen;
5807       gboolean text_modified;
5808       gulong popup_menu_id;
5809
5810       gtk_tree_view_ensure_interactive_directory (tree_view);
5811
5812       /* Make a copy of the current text */
5813       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5814       new_event = gdk_event_copy ((GdkEvent *) event);
5815       g_object_unref (((GdkEventKey *) new_event)->window);
5816       ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
5817       gtk_widget_realize (tree_view->priv->search_window);
5818
5819       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5820                                         "popup-menu", G_CALLBACK (gtk_true),
5821                                         NULL);
5822
5823       /* Move the entry off screen */
5824       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5825       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5826                        gdk_screen_get_width (screen) + 1,
5827                        gdk_screen_get_height (screen) + 1);
5828       gtk_widget_show (tree_view->priv->search_window);
5829
5830       /* Send the event to the window.  If the preedit_changed signal is emitted
5831        * during this event, we will set priv->imcontext_changed  */
5832       tree_view->priv->imcontext_changed = FALSE;
5833       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5834       gdk_event_free (new_event);
5835       gtk_widget_hide (tree_view->priv->search_window);
5836
5837       g_signal_handler_disconnect (tree_view->priv->search_entry,
5838                                    popup_menu_id);
5839
5840       /* We check to make sure that the entry tried to handle the text, and that
5841        * the text has changed.
5842        */
5843       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5844       text_modified = strcmp (old_text, new_text) != 0;
5845       g_free (old_text);
5846       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5847           (retval && text_modified))               /* ...or the text was modified */
5848         {
5849           if (gtk_tree_view_real_start_interactive_search (tree_view,
5850                                                            gdk_event_get_device ((GdkEvent *) event),
5851                                                            FALSE))
5852             {
5853               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5854               return TRUE;
5855             }
5856           else
5857             {
5858               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5859               return FALSE;
5860             }
5861         }
5862     }
5863
5864   return FALSE;
5865 }
5866
5867 static gboolean
5868 gtk_tree_view_key_release (GtkWidget   *widget,
5869                            GdkEventKey *event)
5870 {
5871   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5872
5873   if (tree_view->priv->rubber_band_status)
5874     return TRUE;
5875
5876   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5877 }
5878
5879 /* FIXME Is this function necessary? Can I get an enter_notify event
5880  * w/o either an expose event or a mouse motion event?
5881  */
5882 static gboolean
5883 gtk_tree_view_enter_notify (GtkWidget        *widget,
5884                             GdkEventCrossing *event)
5885 {
5886   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5887   GtkRBTree *tree;
5888   GtkRBNode *node;
5889   gint new_y;
5890
5891   /* Sanity check it */
5892   if (event->window != tree_view->priv->bin_window)
5893     return FALSE;
5894
5895   if (tree_view->priv->tree == NULL)
5896     return FALSE;
5897
5898   if (event->mode == GDK_CROSSING_GRAB ||
5899       event->mode == GDK_CROSSING_GTK_GRAB ||
5900       event->mode == GDK_CROSSING_GTK_UNGRAB ||
5901       event->mode == GDK_CROSSING_STATE_CHANGED)
5902     return TRUE;
5903
5904   /* find the node internally */
5905   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5906   if (new_y < 0)
5907     new_y = 0;
5908   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5909
5910   tree_view->priv->event_last_x = event->x;
5911   tree_view->priv->event_last_y = event->y;
5912
5913   if ((tree_view->priv->button_pressed_node == NULL) ||
5914       (tree_view->priv->button_pressed_node == node))
5915     prelight_or_select (tree_view, tree, node, event->x, event->y);
5916
5917   return TRUE;
5918 }
5919
5920 static gboolean
5921 gtk_tree_view_leave_notify (GtkWidget        *widget,
5922                             GdkEventCrossing *event)
5923 {
5924   GtkTreeView *tree_view;
5925
5926   if (event->mode == GDK_CROSSING_GRAB ||
5927       event->mode == GDK_CROSSING_GTK_GRAB ||
5928       event->mode == GDK_CROSSING_GTK_UNGRAB)
5929     return TRUE;
5930
5931   tree_view = GTK_TREE_VIEW (widget);
5932
5933   if (tree_view->priv->prelight_node)
5934     _gtk_tree_view_queue_draw_node (tree_view,
5935                                    tree_view->priv->prelight_tree,
5936                                    tree_view->priv->prelight_node,
5937                                    NULL);
5938
5939   tree_view->priv->event_last_x = -10000;
5940   tree_view->priv->event_last_y = -10000;
5941
5942   prelight_or_select (tree_view,
5943                       NULL, NULL,
5944                       -1000, -1000); /* coords not possibly over an arrow */
5945
5946   return TRUE;
5947 }
5948
5949
5950 static gint
5951 gtk_tree_view_focus_out (GtkWidget     *widget,
5952                          GdkEventFocus *event)
5953 {
5954   GtkTreeView *tree_view;
5955
5956   tree_view = GTK_TREE_VIEW (widget);
5957
5958   gtk_widget_queue_draw (widget);
5959
5960   /* destroy interactive search dialog */
5961   if (tree_view->priv->search_window)
5962     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
5963                                       gdk_event_get_device ((GdkEvent *) event));
5964
5965   return FALSE;
5966 }
5967
5968
5969 /* Incremental Reflow
5970  */
5971
5972 static void
5973 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
5974                                  GtkRBTree   *tree,
5975                                  GtkRBNode   *node)
5976 {
5977   GtkAllocation allocation;
5978   gint y;
5979
5980   y = _gtk_rbtree_node_find_offset (tree, node)
5981     - gtk_adjustment_get_value (tree_view->priv->vadjustment)
5982     + gtk_tree_view_get_effective_header_height (tree_view);
5983
5984   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
5985   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
5986                               0, y,
5987                               allocation.width,
5988                               GTK_RBNODE_GET_HEIGHT (node));
5989 }
5990
5991 static gboolean
5992 node_is_visible (GtkTreeView *tree_view,
5993                  GtkRBTree   *tree,
5994                  GtkRBNode   *node)
5995 {
5996   int y;
5997   int height;
5998
5999   y = _gtk_rbtree_node_find_offset (tree, node);
6000   height = gtk_tree_view_get_row_height (tree_view, node);
6001
6002   if (y >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6003       y + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6004                      + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6005     return TRUE;
6006
6007   return FALSE;
6008 }
6009
6010 /* Returns TRUE if it updated the size
6011  */
6012 static gboolean
6013 validate_row (GtkTreeView *tree_view,
6014               GtkRBTree   *tree,
6015               GtkRBNode   *node,
6016               GtkTreeIter *iter,
6017               GtkTreePath *path)
6018 {
6019   GtkTreeViewColumn *column;
6020   GList *list, *first_column, *last_column;
6021   gint height = 0;
6022   gint horizontal_separator;
6023   gint vertical_separator;
6024   gint depth = gtk_tree_path_get_depth (path);
6025   gboolean retval = FALSE;
6026   gboolean is_separator = FALSE;
6027   gboolean draw_vgrid_lines, draw_hgrid_lines;
6028   gint focus_pad;
6029   gint grid_line_width;
6030   gboolean wide_separators;
6031   gint separator_height;
6032   gint expander_size;
6033
6034   /* double check the row needs validating */
6035   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
6036       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6037     return FALSE;
6038
6039   is_separator = row_is_separator (tree_view, iter, NULL);
6040
6041   gtk_widget_style_get (GTK_WIDGET (tree_view),
6042                         "focus-padding", &focus_pad,
6043                         "horizontal-separator", &horizontal_separator,
6044                         "vertical-separator", &vertical_separator,
6045                         "grid-line-width", &grid_line_width,
6046                         "wide-separators",  &wide_separators,
6047                         "separator-height", &separator_height,
6048                         NULL);
6049
6050   draw_vgrid_lines =
6051     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
6052     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6053   draw_hgrid_lines =
6054     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
6055     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6056   expander_size = gtk_tree_view_get_expander_size (tree_view);
6057
6058   for (last_column = g_list_last (tree_view->priv->columns);
6059        last_column &&
6060        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
6061        last_column = last_column->prev)
6062     ;
6063
6064   for (first_column = g_list_first (tree_view->priv->columns);
6065        first_column &&
6066        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
6067        first_column = first_column->next)
6068     ;
6069
6070   for (list = tree_view->priv->columns; list; list = list->next)
6071     {
6072       gint padding = 0;
6073       gint original_width;
6074       gint new_width;
6075       gint row_height;
6076
6077       column = list->data;
6078
6079       if (!gtk_tree_view_column_get_visible (column))
6080         continue;
6081
6082       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) &&
6083           !_gtk_tree_view_column_cell_get_dirty (column))
6084         continue;
6085
6086       original_width = _gtk_tree_view_column_get_requested_width (column);
6087
6088       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
6089                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
6090                                                node->children?TRUE:FALSE);
6091       gtk_tree_view_column_cell_get_size (column,
6092                                           NULL, NULL, NULL,
6093                                           NULL, &row_height);
6094
6095       if (!is_separator)
6096         {
6097           row_height += vertical_separator;
6098           height = MAX (height, row_height);
6099           height = MAX (height, expander_size);
6100         }
6101       else
6102         {
6103           if (wide_separators)
6104             height = separator_height + 2 * focus_pad;
6105           else
6106             height = 2 + 2 * focus_pad;
6107         }
6108
6109       if (gtk_tree_view_is_expander_column (tree_view, column))
6110         {
6111           padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
6112
6113           if (gtk_tree_view_draw_expanders (tree_view))
6114             padding += depth * expander_size;
6115         }
6116       else
6117         padding += horizontal_separator;
6118
6119       if (draw_vgrid_lines)
6120         {
6121           if (list->data == first_column || list->data == last_column)
6122             padding += grid_line_width / 2.0;
6123           else
6124             padding += grid_line_width;
6125         }
6126
6127       /* Update the padding for the column */
6128       _gtk_tree_view_column_push_padding (column, padding);
6129       new_width = _gtk_tree_view_column_get_requested_width (column);
6130
6131       if (new_width > original_width)
6132         retval = TRUE;
6133     }
6134
6135   if (draw_hgrid_lines)
6136     height += grid_line_width;
6137
6138   if (height != GTK_RBNODE_GET_HEIGHT (node))
6139     {
6140       retval = TRUE;
6141       _gtk_rbtree_node_set_height (tree, node, height);
6142     }
6143   _gtk_rbtree_node_mark_valid (tree, node);
6144
6145   return retval;
6146 }
6147
6148
6149 static void
6150 validate_visible_area (GtkTreeView *tree_view)
6151 {
6152   GtkAllocation allocation;
6153   GtkTreePath *path = NULL;
6154   GtkTreePath *above_path = NULL;
6155   GtkTreeIter iter;
6156   GtkRBTree *tree = NULL;
6157   GtkRBNode *node = NULL;
6158   gboolean need_redraw = FALSE;
6159   gboolean size_changed = FALSE;
6160   gint total_height;
6161   gint area_above = 0;
6162   gint area_below = 0;
6163
6164   if (tree_view->priv->tree == NULL)
6165     return;
6166
6167   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
6168       tree_view->priv->scroll_to_path == NULL)
6169     return;
6170
6171   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
6172   total_height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
6173
6174   if (total_height == 0)
6175     return;
6176
6177   /* First, we check to see if we need to scroll anywhere
6178    */
6179   if (tree_view->priv->scroll_to_path)
6180     {
6181       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
6182       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
6183         {
6184           /* we are going to scroll, and will update dy */
6185           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6186           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6187               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6188             {
6189               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6190               if (validate_row (tree_view, tree, node, &iter, path))
6191                 size_changed = TRUE;
6192             }
6193
6194           if (tree_view->priv->scroll_to_use_align)
6195             {
6196               gint height = gtk_tree_view_get_row_height (tree_view, node);
6197               area_above = (total_height - height) *
6198                 tree_view->priv->scroll_to_row_align;
6199               area_below = total_height - area_above - height;
6200               area_above = MAX (area_above, 0);
6201               area_below = MAX (area_below, 0);
6202             }
6203           else
6204             {
6205               /* two cases:
6206                * 1) row not visible
6207                * 2) row visible
6208                */
6209               gint dy;
6210               gint height = gtk_tree_view_get_row_height (tree_view, node);
6211
6212               dy = _gtk_rbtree_node_find_offset (tree, node);
6213
6214               if (dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6215                   dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6216                                   + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6217                 {
6218                   /* row visible: keep the row at the same position */
6219                   area_above = dy - gtk_adjustment_get_value (tree_view->priv->vadjustment);
6220                   area_below = (gtk_adjustment_get_value (tree_view->priv->vadjustment) +
6221                                 gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6222                                - dy - height;
6223                 }
6224               else
6225                 {
6226                   /* row not visible */
6227                   if (dy >= 0
6228                       && dy + height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6229                     {
6230                       /* row at the beginning -- fixed */
6231                       area_above = dy;
6232                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment)
6233                                    - area_above - height;
6234                     }
6235                   else if (dy >= (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6236                                   gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6237                     {
6238                       /* row at the end -- fixed */
6239                       area_above = dy - (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6240                                    gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6241                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) -
6242                                    area_above - height;
6243
6244                       if (area_below < 0)
6245                         {
6246                           area_above = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - height;
6247                           area_below = 0;
6248                         }
6249                     }
6250                   else
6251                     {
6252                       /* row somewhere in the middle, bring it to the top
6253                        * of the view
6254                        */
6255                       area_above = 0;
6256                       area_below = total_height - height;
6257                     }
6258                 }
6259             }
6260         }
6261       else
6262         /* the scroll to isn't valid; ignore it.
6263          */
6264         {
6265           if (tree_view->priv->scroll_to_path && !path)
6266             {
6267               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6268               tree_view->priv->scroll_to_path = NULL;
6269             }
6270           if (path)
6271             gtk_tree_path_free (path);
6272           path = NULL;
6273         }
6274     }
6275
6276   /* We didn't have a scroll_to set, so we just handle things normally
6277    */
6278   if (path == NULL)
6279     {
6280       gint offset;
6281
6282       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6283                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
6284                                         &tree, &node);
6285       if (node == NULL)
6286         {
6287           /* In this case, nothing has been validated */
6288           path = gtk_tree_path_new_first ();
6289           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6290         }
6291       else
6292         {
6293           path = _gtk_tree_path_new_from_rbtree (tree, node);
6294           total_height += offset;
6295         }
6296
6297       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6298
6299       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6300           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6301         {
6302           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6303           if (validate_row (tree_view, tree, node, &iter, path))
6304             size_changed = TRUE;
6305         }
6306       area_above = 0;
6307       area_below = total_height - gtk_tree_view_get_row_height (tree_view, node);
6308     }
6309
6310   above_path = gtk_tree_path_copy (path);
6311
6312   /* if we do not validate any row above the new top_row, we will make sure
6313    * that the row immediately above top_row has been validated. (if we do not
6314    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
6315    * when invalidated that row's height will be zero. and this will mess up
6316    * scrolling).
6317    */
6318   if (area_above == 0)
6319     {
6320       GtkRBTree *tmptree;
6321       GtkRBNode *tmpnode;
6322
6323       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
6324       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
6325
6326       if (tmpnode)
6327         {
6328           GtkTreePath *tmppath;
6329           GtkTreeIter tmpiter;
6330
6331           tmppath = _gtk_tree_path_new_from_rbtree (tmptree, tmpnode);
6332           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
6333
6334           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
6335               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
6336             {
6337               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
6338               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
6339                 size_changed = TRUE;
6340             }
6341
6342           gtk_tree_path_free (tmppath);
6343         }
6344     }
6345
6346   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
6347    * backwards is much slower then forward, as there is no iter_prev function.
6348    * We go forwards first in case we run out of tree.  Then we go backwards to
6349    * fill out the top.
6350    */
6351   while (node && area_below > 0)
6352     {
6353       if (node->children)
6354         {
6355           GtkTreeIter parent = iter;
6356           gboolean has_child;
6357
6358           tree = node->children;
6359           node = _gtk_rbtree_first (tree);
6360
6361           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
6362                                                     &iter,
6363                                                     &parent);
6364           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
6365           gtk_tree_path_down (path);
6366         }
6367       else
6368         {
6369           gboolean done = FALSE;
6370           do
6371             {
6372               node = _gtk_rbtree_next (tree, node);
6373               if (node != NULL)
6374                 {
6375                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
6376                   done = TRUE;
6377                   gtk_tree_path_next (path);
6378
6379                   /* Sanity Check! */
6380                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
6381                 }
6382               else
6383                 {
6384                   GtkTreeIter parent_iter = iter;
6385                   gboolean has_parent;
6386
6387                   node = tree->parent_node;
6388                   tree = tree->parent_tree;
6389                   if (tree == NULL)
6390                     break;
6391                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
6392                                                            &iter,
6393                                                            &parent_iter);
6394                   gtk_tree_path_up (path);
6395
6396                   /* Sanity check */
6397                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
6398                 }
6399             }
6400           while (!done);
6401         }
6402
6403       if (!node)
6404         break;
6405
6406       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6407           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6408         {
6409           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6410           if (validate_row (tree_view, tree, node, &iter, path))
6411               size_changed = TRUE;
6412         }
6413
6414       area_below -= gtk_tree_view_get_row_height (tree_view, node);
6415     }
6416   gtk_tree_path_free (path);
6417
6418   /* If we ran out of tree, and have extra area_below left, we need to add it
6419    * to area_above */
6420   if (area_below > 0)
6421     area_above += area_below;
6422
6423   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
6424
6425   /* We walk backwards */
6426   while (area_above > 0)
6427     {
6428       _gtk_rbtree_prev_full (tree, node, &tree, &node);
6429
6430       /* Always find the new path in the tree.  We cannot just assume
6431        * a gtk_tree_path_prev() is enough here, as there might be children
6432        * in between this node and the previous sibling node.  If this
6433        * appears to be a performance hotspot in profiles, we can look into
6434        * intrigate logic for keeping path, node and iter in sync like
6435        * we do for forward walks.  (Which will be hard because of the lacking
6436        * iter_prev).
6437        */
6438
6439       if (node == NULL)
6440         break;
6441
6442       gtk_tree_path_free (above_path);
6443       above_path = _gtk_tree_path_new_from_rbtree (tree, node);
6444
6445       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
6446
6447       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6448           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6449         {
6450           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6451           if (validate_row (tree_view, tree, node, &iter, above_path))
6452             size_changed = TRUE;
6453         }
6454       area_above -= gtk_tree_view_get_row_height (tree_view, node);
6455     }
6456
6457   /* if we scrolled to a path, we need to set the dy here,
6458    * and sync the top row accordingly
6459    */
6460   if (tree_view->priv->scroll_to_path)
6461     {
6462       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6463       gtk_tree_view_top_row_to_dy (tree_view);
6464
6465       need_redraw = TRUE;
6466     }
6467   else if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6468     {
6469       /* when we are not scrolling, we should never set dy to something
6470        * else than zero. we update top_row to be in sync with dy = 0.
6471        */
6472       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6473       gtk_tree_view_dy_to_top_row (tree_view);
6474     }
6475   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6476     {
6477       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6478       gtk_tree_view_dy_to_top_row (tree_view);
6479     }
6480   else
6481     gtk_tree_view_top_row_to_dy (tree_view);
6482
6483   /* update width/height and queue a resize */
6484   if (size_changed)
6485     {
6486       GtkRequisition requisition;
6487
6488       /* We temporarily guess a size, under the assumption that it will be the
6489        * same when we get our next size_allocate.  If we don't do this, we'll be
6490        * in an inconsistent state if we call top_row_to_dy. */
6491
6492       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6493                                      &requisition, NULL);
6494       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6495                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6496       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6497                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6498       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6499     }
6500
6501   if (tree_view->priv->scroll_to_path)
6502     {
6503       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6504       tree_view->priv->scroll_to_path = NULL;
6505     }
6506
6507   if (above_path)
6508     gtk_tree_path_free (above_path);
6509
6510   if (tree_view->priv->scroll_to_column)
6511     {
6512       tree_view->priv->scroll_to_column = NULL;
6513     }
6514   if (need_redraw)
6515     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6516 }
6517
6518 static void
6519 initialize_fixed_height_mode (GtkTreeView *tree_view)
6520 {
6521   if (!tree_view->priv->tree)
6522     return;
6523
6524   if (tree_view->priv->fixed_height < 0)
6525     {
6526       GtkTreeIter iter;
6527       GtkTreePath *path;
6528
6529       GtkRBTree *tree = NULL;
6530       GtkRBNode *node = NULL;
6531
6532       tree = tree_view->priv->tree;
6533       node = tree->root;
6534
6535       path = _gtk_tree_path_new_from_rbtree (tree, node);
6536       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6537
6538       validate_row (tree_view, tree, node, &iter, path);
6539
6540       gtk_tree_path_free (path);
6541
6542       tree_view->priv->fixed_height = gtk_tree_view_get_row_height (tree_view, node);
6543     }
6544
6545    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6546                                  tree_view->priv->fixed_height, TRUE);
6547 }
6548
6549 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6550  * the left-most uninvalidated node.  We then try walking right, validating
6551  * nodes.  Once we find a valid node, we repeat the previous process of finding
6552  * the first invalid node.
6553  */
6554
6555 static gboolean
6556 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6557 {
6558   static gboolean prevent_recursion_hack = FALSE;
6559
6560   GtkRBTree *tree = NULL;
6561   GtkRBNode *node = NULL;
6562   gboolean validated_area = FALSE;
6563   gint retval = TRUE;
6564   GtkTreePath *path = NULL;
6565   GtkTreeIter iter;
6566   GTimer *timer;
6567   gint i = 0;
6568
6569   gint y = -1;
6570   gint prev_height = -1;
6571   gboolean fixed_height = TRUE;
6572
6573   g_assert (tree_view);
6574
6575   /* prevent infinite recursion via get_preferred_width() */
6576   if (prevent_recursion_hack)
6577     return FALSE;
6578
6579   if (tree_view->priv->tree == NULL)
6580       return FALSE;
6581
6582   if (tree_view->priv->fixed_height_mode)
6583     {
6584       if (tree_view->priv->fixed_height < 0)
6585         initialize_fixed_height_mode (tree_view);
6586
6587       return FALSE;
6588     }
6589
6590   timer = g_timer_new ();
6591   g_timer_start (timer);
6592
6593   do
6594     {
6595       gboolean changed = FALSE;
6596
6597       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6598         {
6599           retval = FALSE;
6600           goto done;
6601         }
6602
6603       if (path != NULL)
6604         {
6605           node = _gtk_rbtree_next (tree, node);
6606           if (node != NULL)
6607             {
6608               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6609               gtk_tree_path_next (path);
6610             }
6611           else
6612             {
6613               gtk_tree_path_free (path);
6614               path = NULL;
6615             }
6616         }
6617
6618       if (path == NULL)
6619         {
6620           tree = tree_view->priv->tree;
6621           node = tree_view->priv->tree->root;
6622
6623           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6624
6625           do
6626             {
6627               if (!_gtk_rbtree_is_nil (node->left) &&
6628                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6629                 {
6630                   node = node->left;
6631                 }
6632               else if (!_gtk_rbtree_is_nil (node->right) &&
6633                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6634                 {
6635                   node = node->right;
6636                 }
6637               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6638                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6639                 {
6640                   break;
6641                 }
6642               else if (node->children != NULL)
6643                 {
6644                   tree = node->children;
6645                   node = tree->root;
6646                 }
6647               else
6648                 /* RBTree corruption!  All bad */
6649                 g_assert_not_reached ();
6650             }
6651           while (TRUE);
6652           path = _gtk_tree_path_new_from_rbtree (tree, node);
6653           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6654         }
6655
6656       changed = validate_row (tree_view, tree, node, &iter, path);
6657       validated_area = changed || validated_area;
6658
6659       if (changed)
6660         {
6661           gint offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
6662
6663           if (y == -1 || y > offset)
6664             y = offset;
6665         }
6666
6667       if (!tree_view->priv->fixed_height_check)
6668         {
6669           gint height;
6670
6671           height = gtk_tree_view_get_row_height (tree_view, node);
6672           if (prev_height < 0)
6673             prev_height = height;
6674           else if (prev_height != height)
6675             fixed_height = FALSE;
6676         }
6677
6678       i++;
6679     }
6680   while (g_timer_elapsed (timer, NULL) < GTK_TREE_VIEW_TIME_MS_PER_IDLE / 1000.);
6681
6682   if (!tree_view->priv->fixed_height_check)
6683    {
6684      if (fixed_height)
6685        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6686
6687      tree_view->priv->fixed_height_check = 1;
6688    }
6689
6690  done:
6691   if (validated_area)
6692     {
6693       GtkRequisition requisition;
6694
6695       /* We temporarily guess a size, under the assumption that it will be the
6696        * same when we get our next size_allocate.  If we don't do this, we'll be
6697        * in an inconsistent state when we call top_row_to_dy. */
6698
6699       /* FIXME: This is called from size_request, for some reason it is not infinitely
6700        * recursing, we cannot call gtk_widget_get_preferred_size() here because that's
6701        * not allowed (from inside ->get_preferred_width/height() implementations, one
6702        * should call the vfuncs directly). However what is desired here is the full
6703        * size including any margins and limited by any alignment (i.e. after
6704        * GtkWidget:adjust_size_request() is called).
6705        *
6706        * Currently bypassing this but the real solution is to not update the scroll adjustments
6707        * untill we've recieved an allocation (never update scroll adjustments from size-requests).
6708        */
6709       prevent_recursion_hack = TRUE;
6710       gtk_tree_view_get_preferred_width (GTK_WIDGET (tree_view), &requisition.width, NULL);
6711       gtk_tree_view_get_preferred_height (GTK_WIDGET (tree_view), &requisition.height, NULL);
6712       prevent_recursion_hack = FALSE;
6713
6714       /* If rows above the current position have changed height, this has
6715        * affected the current view and thus needs a redraw.
6716        */
6717       if (y != -1 && y < gtk_adjustment_get_value (tree_view->priv->vadjustment))
6718         gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6719
6720       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6721                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6722       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6723                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6724
6725       if (queue_resize)
6726         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
6727     }
6728
6729   if (path) gtk_tree_path_free (path);
6730   g_timer_destroy (timer);
6731
6732   return retval;
6733 }
6734
6735 static gboolean
6736 validate_rows (GtkTreeView *tree_view)
6737 {
6738   gboolean retval;
6739
6740   retval = do_validate_rows (tree_view, TRUE);
6741
6742   if (! retval && tree_view->priv->validate_rows_timer)
6743     {
6744       g_source_remove (tree_view->priv->validate_rows_timer);
6745       tree_view->priv->validate_rows_timer = 0;
6746     }
6747
6748   return retval;
6749 }
6750
6751 static gboolean
6752 validate_rows_handler (GtkTreeView *tree_view)
6753 {
6754   gboolean retval;
6755
6756   retval = do_validate_rows (tree_view, TRUE);
6757   if (! retval && tree_view->priv->validate_rows_timer)
6758     {
6759       g_source_remove (tree_view->priv->validate_rows_timer);
6760       tree_view->priv->validate_rows_timer = 0;
6761     }
6762
6763   return retval;
6764 }
6765
6766 static gboolean
6767 do_presize_handler (GtkTreeView *tree_view)
6768 {
6769   if (tree_view->priv->mark_rows_col_dirty)
6770     {
6771       if (tree_view->priv->tree)
6772         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6773       tree_view->priv->mark_rows_col_dirty = FALSE;
6774     }
6775   validate_visible_area (tree_view);
6776   tree_view->priv->presize_handler_timer = 0;
6777
6778   if (tree_view->priv->fixed_height_mode)
6779     {
6780       GtkRequisition requisition;
6781
6782       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6783                                      &requisition, NULL);
6784
6785       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6786                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6787       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6788                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6789       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6790     }
6791
6792   return FALSE;
6793 }
6794
6795 static gboolean
6796 presize_handler_callback (gpointer data)
6797 {
6798   do_presize_handler (GTK_TREE_VIEW (data));
6799
6800   return FALSE;
6801 }
6802
6803 static void
6804 install_presize_handler (GtkTreeView *tree_view)
6805 {
6806   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6807     return;
6808
6809   if (! tree_view->priv->presize_handler_timer)
6810     {
6811       tree_view->priv->presize_handler_timer =
6812         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6813     }
6814   if (! tree_view->priv->validate_rows_timer)
6815     {
6816       tree_view->priv->validate_rows_timer =
6817         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6818     }
6819 }
6820
6821 static gboolean
6822 scroll_sync_handler (GtkTreeView *tree_view)
6823 {
6824   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6825     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6826   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6827     gtk_tree_view_top_row_to_dy (tree_view);
6828   else
6829     gtk_tree_view_dy_to_top_row (tree_view);
6830
6831   tree_view->priv->scroll_sync_timer = 0;
6832
6833   return FALSE;
6834 }
6835
6836 static void
6837 install_scroll_sync_handler (GtkTreeView *tree_view)
6838 {
6839   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6840     return;
6841
6842   if (!tree_view->priv->scroll_sync_timer)
6843     {
6844       tree_view->priv->scroll_sync_timer =
6845         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6846     }
6847 }
6848
6849 static void
6850 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6851                            GtkTreePath *path,
6852                            gint         offset)
6853 {
6854   gtk_tree_row_reference_free (tree_view->priv->top_row);
6855
6856   if (!path)
6857     {
6858       tree_view->priv->top_row = NULL;
6859       tree_view->priv->top_row_dy = 0;
6860     }
6861   else
6862     {
6863       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6864       tree_view->priv->top_row_dy = offset;
6865     }
6866 }
6867
6868 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6869  * it's set to be NULL, and top_row_dy is 0;
6870  */
6871 static void
6872 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6873 {
6874   gint offset;
6875   GtkTreePath *path;
6876   GtkRBTree *tree;
6877   GtkRBNode *node;
6878
6879   if (tree_view->priv->tree == NULL)
6880     {
6881       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6882     }
6883   else
6884     {
6885       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6886                                         tree_view->priv->dy,
6887                                         &tree, &node);
6888
6889       if (tree == NULL)
6890         {
6891           gtk_tree_view_set_top_row (tree_view, NULL, 0);
6892         }
6893       else
6894         {
6895           path = _gtk_tree_path_new_from_rbtree (tree, node);
6896           gtk_tree_view_set_top_row (tree_view, path, offset);
6897           gtk_tree_path_free (path);
6898         }
6899     }
6900 }
6901
6902 static void
6903 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6904 {
6905   GtkTreePath *path;
6906   GtkRBTree *tree;
6907   GtkRBNode *node;
6908   int new_dy;
6909
6910   /* Avoid recursive calls */
6911   if (tree_view->priv->in_top_row_to_dy)
6912     return;
6913
6914   if (tree_view->priv->top_row)
6915     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6916   else
6917     path = NULL;
6918
6919   if (!path)
6920     tree = NULL;
6921   else
6922     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6923
6924   if (path)
6925     gtk_tree_path_free (path);
6926
6927   if (tree == NULL)
6928     {
6929       /* keep dy and set new toprow */
6930       gtk_tree_row_reference_free (tree_view->priv->top_row);
6931       tree_view->priv->top_row = NULL;
6932       tree_view->priv->top_row_dy = 0;
6933       /* DO NOT install the idle handler */
6934       gtk_tree_view_dy_to_top_row (tree_view);
6935       return;
6936     }
6937
6938   if (gtk_tree_view_get_row_height (tree_view, node)
6939       < tree_view->priv->top_row_dy)
6940     {
6941       /* new top row -- do NOT install the idle handler */
6942       gtk_tree_view_dy_to_top_row (tree_view);
6943       return;
6944     }
6945
6946   new_dy = _gtk_rbtree_node_find_offset (tree, node);
6947   new_dy += tree_view->priv->top_row_dy;
6948
6949   if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6950     new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
6951
6952   new_dy = MAX (0, new_dy);
6953
6954   tree_view->priv->in_top_row_to_dy = TRUE;
6955   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
6956   tree_view->priv->in_top_row_to_dy = FALSE;
6957 }
6958
6959
6960 void
6961 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view,
6962                                             gboolean     install_handler)
6963 {
6964   tree_view->priv->mark_rows_col_dirty = TRUE;
6965
6966   if (install_handler)
6967     install_presize_handler (tree_view);
6968 }
6969
6970 /*
6971  * This function works synchronously (due to the while (validate_rows...)
6972  * loop).
6973  *
6974  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
6975  * here. You now need to check that yourself.
6976  */
6977 void
6978 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
6979                                 GtkTreeViewColumn *column)
6980 {
6981   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6982   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
6983
6984   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
6985
6986   do_presize_handler (tree_view);
6987   while (validate_rows (tree_view));
6988
6989   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6990 }
6991
6992 /* Drag-and-drop */
6993
6994 static void
6995 set_source_row (GdkDragContext *context,
6996                 GtkTreeModel   *model,
6997                 GtkTreePath    *source_row)
6998 {
6999   g_object_set_data_full (G_OBJECT (context),
7000                           I_("gtk-tree-view-source-row"),
7001                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
7002                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
7003 }
7004
7005 static GtkTreePath*
7006 get_source_row (GdkDragContext *context)
7007 {
7008   GtkTreeRowReference *ref =
7009     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
7010
7011   if (ref)
7012     return gtk_tree_row_reference_get_path (ref);
7013   else
7014     return NULL;
7015 }
7016
7017 typedef struct
7018 {
7019   GtkTreeRowReference *dest_row;
7020   guint                path_down_mode   : 1;
7021   guint                empty_view_drop  : 1;
7022   guint                drop_append_mode : 1;
7023 }
7024 DestRow;
7025
7026 static void
7027 dest_row_free (gpointer data)
7028 {
7029   DestRow *dr = (DestRow *)data;
7030
7031   gtk_tree_row_reference_free (dr->dest_row);
7032   g_slice_free (DestRow, dr);
7033 }
7034
7035 static void
7036 set_dest_row (GdkDragContext *context,
7037               GtkTreeModel   *model,
7038               GtkTreePath    *dest_row,
7039               gboolean        path_down_mode,
7040               gboolean        empty_view_drop,
7041               gboolean        drop_append_mode)
7042 {
7043   DestRow *dr;
7044
7045   if (!dest_row)
7046     {
7047       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7048                               NULL, NULL);
7049       return;
7050     }
7051
7052   dr = g_slice_new (DestRow);
7053
7054   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
7055   dr->path_down_mode = path_down_mode != FALSE;
7056   dr->empty_view_drop = empty_view_drop != FALSE;
7057   dr->drop_append_mode = drop_append_mode != FALSE;
7058
7059   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7060                           dr, (GDestroyNotify) dest_row_free);
7061 }
7062
7063 static GtkTreePath*
7064 get_dest_row (GdkDragContext *context,
7065               gboolean       *path_down_mode)
7066 {
7067   DestRow *dr =
7068     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
7069
7070   if (dr)
7071     {
7072       GtkTreePath *path = NULL;
7073
7074       if (path_down_mode)
7075         *path_down_mode = dr->path_down_mode;
7076
7077       if (dr->dest_row)
7078         path = gtk_tree_row_reference_get_path (dr->dest_row);
7079       else if (dr->empty_view_drop)
7080         path = gtk_tree_path_new_from_indices (0, -1);
7081       else
7082         path = NULL;
7083
7084       if (path && dr->drop_append_mode)
7085         gtk_tree_path_next (path);
7086
7087       return path;
7088     }
7089   else
7090     return NULL;
7091 }
7092
7093 /* Get/set whether drag_motion requested the drag data and
7094  * drag_data_received should thus not actually insert the data,
7095  * since the data doesn't result from a drop.
7096  */
7097 static void
7098 set_status_pending (GdkDragContext *context,
7099                     GdkDragAction   suggested_action)
7100 {
7101   g_object_set_data (G_OBJECT (context),
7102                      I_("gtk-tree-view-status-pending"),
7103                      GINT_TO_POINTER (suggested_action));
7104 }
7105
7106 static GdkDragAction
7107 get_status_pending (GdkDragContext *context)
7108 {
7109   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
7110                                              "gtk-tree-view-status-pending"));
7111 }
7112
7113 static TreeViewDragInfo*
7114 get_info (GtkTreeView *tree_view)
7115 {
7116   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
7117 }
7118
7119 static void
7120 destroy_info (TreeViewDragInfo *di)
7121 {
7122   g_slice_free (TreeViewDragInfo, di);
7123 }
7124
7125 static TreeViewDragInfo*
7126 ensure_info (GtkTreeView *tree_view)
7127 {
7128   TreeViewDragInfo *di;
7129
7130   di = get_info (tree_view);
7131
7132   if (di == NULL)
7133     {
7134       di = g_slice_new0 (TreeViewDragInfo);
7135
7136       g_object_set_data_full (G_OBJECT (tree_view),
7137                               I_("gtk-tree-view-drag-info"),
7138                               di,
7139                               (GDestroyNotify) destroy_info);
7140     }
7141
7142   return di;
7143 }
7144
7145 static void
7146 remove_info (GtkTreeView *tree_view)
7147 {
7148   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
7149 }
7150
7151 #if 0
7152 static gint
7153 drag_scan_timeout (gpointer data)
7154 {
7155   GtkTreeView *tree_view;
7156   gint x, y;
7157   GdkModifierType state;
7158   GtkTreePath *path = NULL;
7159   GtkTreeViewColumn *column = NULL;
7160   GdkRectangle visible_rect;
7161
7162   gdk_threads_enter ();
7163
7164   tree_view = GTK_TREE_VIEW (data);
7165
7166   gdk_window_get_device_position (tree_view->priv->bin_window,
7167                                   gdk_device_manager_get_client_pointer (
7168                                     gdk_display_get_device_manager (
7169                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
7170                                   &x, &y, &state);
7171
7172   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
7173
7174   /* See if we are near the edge. */
7175   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
7176       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
7177       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
7178       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
7179     {
7180       gtk_tree_view_get_path_at_pos (tree_view,
7181                                      tree_view->priv->bin_window,
7182                                      x, y,
7183                                      &path,
7184                                      &column,
7185                                      NULL,
7186                                      NULL);
7187
7188       if (path != NULL)
7189         {
7190           gtk_tree_view_scroll_to_cell (tree_view,
7191                                         path,
7192                                         column,
7193                                         TRUE,
7194                                         0.5, 0.5);
7195
7196           gtk_tree_path_free (path);
7197         }
7198     }
7199
7200   gdk_threads_leave ();
7201
7202   return TRUE;
7203 }
7204 #endif /* 0 */
7205
7206 static void
7207 add_scroll_timeout (GtkTreeView *tree_view)
7208 {
7209   if (tree_view->priv->scroll_timeout == 0)
7210     {
7211       tree_view->priv->scroll_timeout =
7212         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
7213     }
7214 }
7215
7216 static void
7217 remove_scroll_timeout (GtkTreeView *tree_view)
7218 {
7219   if (tree_view->priv->scroll_timeout != 0)
7220     {
7221       g_source_remove (tree_view->priv->scroll_timeout);
7222       tree_view->priv->scroll_timeout = 0;
7223     }
7224 }
7225
7226 static gboolean
7227 check_model_dnd (GtkTreeModel *model,
7228                  GType         required_iface,
7229                  const gchar  *signal)
7230 {
7231   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
7232     {
7233       g_warning ("You must override the default '%s' handler "
7234                  "on GtkTreeView when using models that don't support "
7235                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
7236                  "is to connect to '%s' and call "
7237                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
7238                  "the default handler from running. Look at the source code "
7239                  "for the default handler in gtktreeview.c to get an idea what "
7240                  "your handler should do. (gtktreeview.c is in the GTK source "
7241                  "code.) If you're using GTK from a language other than C, "
7242                  "there may be a more natural way to override default handlers, e.g. via derivation.",
7243                  signal, g_type_name (required_iface), signal);
7244       return FALSE;
7245     }
7246   else
7247     return TRUE;
7248 }
7249
7250 static void
7251 remove_open_timeout (GtkTreeView *tree_view)
7252 {
7253   if (tree_view->priv->open_dest_timeout != 0)
7254     {
7255       g_source_remove (tree_view->priv->open_dest_timeout);
7256       tree_view->priv->open_dest_timeout = 0;
7257     }
7258 }
7259
7260
7261 static gint
7262 open_row_timeout (gpointer data)
7263 {
7264   GtkTreeView *tree_view = data;
7265   GtkTreePath *dest_path = NULL;
7266   GtkTreeViewDropPosition pos;
7267   gboolean result = FALSE;
7268
7269   gtk_tree_view_get_drag_dest_row (tree_view,
7270                                    &dest_path,
7271                                    &pos);
7272
7273   if (dest_path &&
7274       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7275        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7276     {
7277       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
7278       tree_view->priv->open_dest_timeout = 0;
7279
7280       gtk_tree_path_free (dest_path);
7281     }
7282   else
7283     {
7284       if (dest_path)
7285         gtk_tree_path_free (dest_path);
7286
7287       result = TRUE;
7288     }
7289
7290   return result;
7291 }
7292
7293 static gboolean
7294 scroll_row_timeout (gpointer data)
7295 {
7296   GtkTreeView *tree_view = data;
7297
7298   gtk_tree_view_vertical_autoscroll (tree_view);
7299
7300   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
7301     gtk_tree_view_update_rubber_band (tree_view);
7302
7303   return TRUE;
7304 }
7305
7306 /* Returns TRUE if event should not be propagated to parent widgets */
7307 static gboolean
7308 set_destination_row (GtkTreeView    *tree_view,
7309                      GdkDragContext *context,
7310                      /* coordinates relative to the widget */
7311                      gint            x,
7312                      gint            y,
7313                      GdkDragAction  *suggested_action,
7314                      GdkAtom        *target)
7315 {
7316   GtkTreePath *path = NULL;
7317   GtkTreeViewDropPosition pos;
7318   GtkTreeViewDropPosition old_pos;
7319   TreeViewDragInfo *di;
7320   GtkWidget *widget;
7321   GtkTreePath *old_dest_path = NULL;
7322   gboolean can_drop = FALSE;
7323
7324   *suggested_action = 0;
7325   *target = GDK_NONE;
7326
7327   widget = GTK_WIDGET (tree_view);
7328
7329   di = get_info (tree_view);
7330
7331   if (di == NULL || y - gtk_tree_view_get_effective_header_height (tree_view) < 0)
7332     {
7333       /* someone unset us as a drag dest, note that if
7334        * we return FALSE drag_leave isn't called
7335        */
7336
7337       gtk_tree_view_set_drag_dest_row (tree_view,
7338                                        NULL,
7339                                        GTK_TREE_VIEW_DROP_BEFORE);
7340
7341       remove_scroll_timeout (GTK_TREE_VIEW (widget));
7342       remove_open_timeout (GTK_TREE_VIEW (widget));
7343
7344       return FALSE; /* no longer a drop site */
7345     }
7346
7347   *target = gtk_drag_dest_find_target (widget, context,
7348                                        gtk_drag_dest_get_target_list (widget));
7349   if (*target == GDK_NONE)
7350     {
7351       return FALSE;
7352     }
7353
7354   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
7355                                           x, y,
7356                                           &path,
7357                                           &pos))
7358     {
7359       gint n_children;
7360       GtkTreeModel *model;
7361
7362       remove_open_timeout (tree_view);
7363
7364       /* the row got dropped on empty space, let's setup a special case
7365        */
7366
7367       if (path)
7368         gtk_tree_path_free (path);
7369
7370       model = gtk_tree_view_get_model (tree_view);
7371
7372       n_children = gtk_tree_model_iter_n_children (model, NULL);
7373       if (n_children)
7374         {
7375           pos = GTK_TREE_VIEW_DROP_AFTER;
7376           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
7377         }
7378       else
7379         {
7380           pos = GTK_TREE_VIEW_DROP_BEFORE;
7381           path = gtk_tree_path_new_from_indices (0, -1);
7382         }
7383
7384       can_drop = TRUE;
7385
7386       goto out;
7387     }
7388
7389   g_assert (path);
7390
7391   /* If we left the current row's "open" zone, unset the timeout for
7392    * opening the row
7393    */
7394   gtk_tree_view_get_drag_dest_row (tree_view,
7395                                    &old_dest_path,
7396                                    &old_pos);
7397
7398   if (old_dest_path &&
7399       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
7400        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7401          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
7402     remove_open_timeout (tree_view);
7403
7404   if (old_dest_path)
7405     gtk_tree_path_free (old_dest_path);
7406
7407   if (TRUE /* FIXME if the location droppable predicate */)
7408     {
7409       can_drop = TRUE;
7410     }
7411
7412 out:
7413   if (can_drop)
7414     {
7415       GtkWidget *source_widget;
7416
7417       *suggested_action = gdk_drag_context_get_suggested_action (context);
7418       source_widget = gtk_drag_get_source_widget (context);
7419
7420       if (source_widget == widget)
7421         {
7422           /* Default to MOVE, unless the user has
7423            * pressed ctrl or shift to affect available actions
7424            */
7425           if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
7426             *suggested_action = GDK_ACTION_MOVE;
7427         }
7428
7429       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7430                                        path, pos);
7431     }
7432   else
7433     {
7434       /* can't drop here */
7435       remove_open_timeout (tree_view);
7436
7437       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7438                                        NULL,
7439                                        GTK_TREE_VIEW_DROP_BEFORE);
7440     }
7441
7442   if (path)
7443     gtk_tree_path_free (path);
7444
7445   return TRUE;
7446 }
7447
7448 static GtkTreePath*
7449 get_logical_dest_row (GtkTreeView *tree_view,
7450                       gboolean    *path_down_mode,
7451                       gboolean    *drop_append_mode)
7452 {
7453   /* adjust path to point to the row the drop goes in front of */
7454   GtkTreePath *path = NULL;
7455   GtkTreeViewDropPosition pos;
7456
7457   g_return_val_if_fail (path_down_mode != NULL, NULL);
7458   g_return_val_if_fail (drop_append_mode != NULL, NULL);
7459
7460   *path_down_mode = FALSE;
7461   *drop_append_mode = 0;
7462
7463   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7464
7465   if (path == NULL)
7466     return NULL;
7467
7468   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
7469     ; /* do nothing */
7470   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
7471            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
7472     *path_down_mode = TRUE;
7473   else
7474     {
7475       GtkTreeIter iter;
7476       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
7477
7478       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
7479
7480       if (!gtk_tree_model_get_iter (model, &iter, path) ||
7481           !gtk_tree_model_iter_next (model, &iter))
7482         *drop_append_mode = 1;
7483       else
7484         {
7485           *drop_append_mode = 0;
7486           gtk_tree_path_next (path);
7487         }
7488     }
7489
7490   return path;
7491 }
7492
7493 static gboolean
7494 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
7495                                         GdkEventMotion   *event)
7496 {
7497   GtkWidget *widget = GTK_WIDGET (tree_view);
7498   GdkDragContext *context;
7499   TreeViewDragInfo *di;
7500   GtkTreePath *path = NULL;
7501   gint button;
7502   gint cell_x, cell_y;
7503   GtkTreeModel *model;
7504   gboolean retval = FALSE;
7505
7506   di = get_info (tree_view);
7507
7508   if (di == NULL || !di->source_set)
7509     goto out;
7510
7511   if (tree_view->priv->pressed_button < 0)
7512     goto out;
7513
7514   if (!gtk_drag_check_threshold (widget,
7515                                  tree_view->priv->press_start_x,
7516                                  tree_view->priv->press_start_y,
7517                                  event->x, event->y))
7518     goto out;
7519
7520   model = gtk_tree_view_get_model (tree_view);
7521
7522   if (model == NULL)
7523     goto out;
7524
7525   button = tree_view->priv->pressed_button;
7526   tree_view->priv->pressed_button = -1;
7527
7528   gtk_tree_view_get_path_at_pos (tree_view,
7529                                  tree_view->priv->press_start_x,
7530                                  tree_view->priv->press_start_y,
7531                                  &path,
7532                                  NULL,
7533                                  &cell_x,
7534                                  &cell_y);
7535
7536   if (path == NULL)
7537     goto out;
7538
7539   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7540       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7541                                            path))
7542     goto out;
7543
7544   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7545     goto out;
7546
7547   /* Now we can begin the drag */
7548
7549   retval = TRUE;
7550
7551   context = gtk_drag_begin (widget,
7552                             gtk_drag_source_get_target_list (widget),
7553                             di->source_actions,
7554                             button,
7555                             (GdkEvent*)event);
7556
7557   set_source_row (context, model, path);
7558
7559  out:
7560   if (path)
7561     gtk_tree_path_free (path);
7562
7563   return retval;
7564 }
7565
7566
7567 static void
7568 gtk_tree_view_drag_begin (GtkWidget      *widget,
7569                           GdkDragContext *context)
7570 {
7571   GtkTreeView *tree_view;
7572   GtkTreePath *path = NULL;
7573   gint cell_x, cell_y;
7574   cairo_surface_t *row_pix;
7575   TreeViewDragInfo *di;
7576
7577   tree_view = GTK_TREE_VIEW (widget);
7578
7579   /* if the user uses a custom DND source impl, we don't set the icon here */
7580   di = get_info (tree_view);
7581
7582   if (di == NULL || !di->source_set)
7583     return;
7584
7585   gtk_tree_view_get_path_at_pos (tree_view,
7586                                  tree_view->priv->press_start_x,
7587                                  tree_view->priv->press_start_y,
7588                                  &path,
7589                                  NULL,
7590                                  &cell_x,
7591                                  &cell_y);
7592
7593   /* If path is NULL, there's nothing we can drag.  For now, we silently
7594    * bail out.  Actually, dragging should not be possible from an empty
7595    * tree view, but there's no way we can cancel that from here.
7596    * Automatically unsetting the tree view as drag source for empty models
7597    * is something that would likely break other people's code ...
7598    */
7599   if (!path)
7600     return;
7601
7602   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7603                                                 path);
7604   cairo_surface_set_device_offset (row_pix,
7605                                    /* the + 1 is for the black border in the icon */
7606                                    - (tree_view->priv->press_start_x + 1),
7607                                    - (cell_y + 1));
7608
7609   gtk_drag_set_icon_surface (context, row_pix);
7610
7611   cairo_surface_destroy (row_pix);
7612   gtk_tree_path_free (path);
7613 }
7614
7615 static void
7616 gtk_tree_view_drag_end (GtkWidget      *widget,
7617                         GdkDragContext *context)
7618 {
7619   /* do nothing */
7620 }
7621
7622 /* Default signal implementations for the drag signals */
7623 static void
7624 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7625                              GdkDragContext   *context,
7626                              GtkSelectionData *selection_data,
7627                              guint             info,
7628                              guint             time)
7629 {
7630   GtkTreeView *tree_view;
7631   GtkTreeModel *model;
7632   TreeViewDragInfo *di;
7633   GtkTreePath *source_row;
7634
7635   tree_view = GTK_TREE_VIEW (widget);
7636
7637   model = gtk_tree_view_get_model (tree_view);
7638
7639   if (model == NULL)
7640     return;
7641
7642   di = get_info (GTK_TREE_VIEW (widget));
7643
7644   if (di == NULL)
7645     return;
7646
7647   source_row = get_source_row (context);
7648
7649   if (source_row == NULL)
7650     return;
7651
7652   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7653    * any model; for DragSource models there are some other targets
7654    * we also support.
7655    */
7656
7657   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7658       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7659                                           source_row,
7660                                           selection_data))
7661     goto done;
7662
7663   /* If drag_data_get does nothing, try providing row data. */
7664   if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7665     {
7666       gtk_tree_set_row_drag_data (selection_data,
7667                                   model,
7668                                   source_row);
7669     }
7670
7671  done:
7672   gtk_tree_path_free (source_row);
7673 }
7674
7675
7676 static void
7677 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7678                                 GdkDragContext *context)
7679 {
7680   TreeViewDragInfo *di;
7681   GtkTreeModel *model;
7682   GtkTreeView *tree_view;
7683   GtkTreePath *source_row;
7684
7685   tree_view = GTK_TREE_VIEW (widget);
7686   model = gtk_tree_view_get_model (tree_view);
7687
7688   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7689     return;
7690
7691   di = get_info (tree_view);
7692
7693   if (di == NULL)
7694     return;
7695
7696   source_row = get_source_row (context);
7697
7698   if (source_row == NULL)
7699     return;
7700
7701   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7702                                          source_row);
7703
7704   gtk_tree_path_free (source_row);
7705
7706   set_source_row (context, NULL, NULL);
7707 }
7708
7709 static void
7710 gtk_tree_view_drag_leave (GtkWidget      *widget,
7711                           GdkDragContext *context,
7712                           guint             time)
7713 {
7714   /* unset any highlight row */
7715   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7716                                    NULL,
7717                                    GTK_TREE_VIEW_DROP_BEFORE);
7718
7719   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7720   remove_open_timeout (GTK_TREE_VIEW (widget));
7721 }
7722
7723
7724 static gboolean
7725 gtk_tree_view_drag_motion (GtkWidget        *widget,
7726                            GdkDragContext   *context,
7727                            /* coordinates relative to the widget */
7728                            gint              x,
7729                            gint              y,
7730                            guint             time)
7731 {
7732   gboolean empty;
7733   GtkTreePath *path = NULL;
7734   GtkTreeViewDropPosition pos;
7735   GtkTreeView *tree_view;
7736   GdkDragAction suggested_action = 0;
7737   GdkAtom target;
7738
7739   tree_view = GTK_TREE_VIEW (widget);
7740
7741   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7742     return FALSE;
7743
7744   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7745
7746   /* we only know this *after* set_desination_row */
7747   empty = tree_view->priv->empty_view_drop;
7748
7749   if (path == NULL && !empty)
7750     {
7751       /* Can't drop here. */
7752       gdk_drag_status (context, 0, time);
7753     }
7754   else
7755     {
7756       if (tree_view->priv->open_dest_timeout == 0 &&
7757           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7758            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7759         {
7760           tree_view->priv->open_dest_timeout =
7761             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7762         }
7763       else
7764         {
7765           add_scroll_timeout (tree_view);
7766         }
7767
7768       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7769         {
7770           /* Request data so we can use the source row when
7771            * determining whether to accept the drop
7772            */
7773           set_status_pending (context, suggested_action);
7774           gtk_drag_get_data (widget, context, target, time);
7775         }
7776       else
7777         {
7778           set_status_pending (context, 0);
7779           gdk_drag_status (context, suggested_action, time);
7780         }
7781     }
7782
7783   if (path)
7784     gtk_tree_path_free (path);
7785
7786   return TRUE;
7787 }
7788
7789
7790 static gboolean
7791 gtk_tree_view_drag_drop (GtkWidget        *widget,
7792                          GdkDragContext   *context,
7793                          /* coordinates relative to the widget */
7794                          gint              x,
7795                          gint              y,
7796                          guint             time)
7797 {
7798   GtkTreeView *tree_view;
7799   GtkTreePath *path;
7800   GdkDragAction suggested_action = 0;
7801   GdkAtom target = GDK_NONE;
7802   TreeViewDragInfo *di;
7803   GtkTreeModel *model;
7804   gboolean path_down_mode;
7805   gboolean drop_append_mode;
7806
7807   tree_view = GTK_TREE_VIEW (widget);
7808
7809   model = gtk_tree_view_get_model (tree_view);
7810
7811   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7812   remove_open_timeout (GTK_TREE_VIEW (widget));
7813
7814   di = get_info (tree_view);
7815
7816   if (di == NULL)
7817     return FALSE;
7818
7819   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7820     return FALSE;
7821
7822   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7823     return FALSE;
7824
7825   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7826
7827   if (target != GDK_NONE && path != NULL)
7828     {
7829       /* in case a motion had requested drag data, change things so we
7830        * treat drag data receives as a drop.
7831        */
7832       set_status_pending (context, 0);
7833       set_dest_row (context, model, path,
7834                     path_down_mode, tree_view->priv->empty_view_drop,
7835                     drop_append_mode);
7836     }
7837
7838   if (path)
7839     gtk_tree_path_free (path);
7840
7841   /* Unset this thing */
7842   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7843                                    NULL,
7844                                    GTK_TREE_VIEW_DROP_BEFORE);
7845
7846   if (target != GDK_NONE)
7847     {
7848       gtk_drag_get_data (widget, context, target, time);
7849       return TRUE;
7850     }
7851   else
7852     return FALSE;
7853 }
7854
7855 static void
7856 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7857                                   GdkDragContext   *context,
7858                                   /* coordinates relative to the widget */
7859                                   gint              x,
7860                                   gint              y,
7861                                   GtkSelectionData *selection_data,
7862                                   guint             info,
7863                                   guint             time)
7864 {
7865   GtkTreePath *path;
7866   TreeViewDragInfo *di;
7867   gboolean accepted = FALSE;
7868   GtkTreeModel *model;
7869   GtkTreeView *tree_view;
7870   GtkTreePath *dest_row;
7871   GdkDragAction suggested_action;
7872   gboolean path_down_mode;
7873   gboolean drop_append_mode;
7874
7875   tree_view = GTK_TREE_VIEW (widget);
7876
7877   model = gtk_tree_view_get_model (tree_view);
7878
7879   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7880     return;
7881
7882   di = get_info (tree_view);
7883
7884   if (di == NULL)
7885     return;
7886
7887   suggested_action = get_status_pending (context);
7888
7889   if (suggested_action)
7890     {
7891       /* We are getting this data due to a request in drag_motion,
7892        * rather than due to a request in drag_drop, so we are just
7893        * supposed to call drag_status, not actually paste in the
7894        * data.
7895        */
7896       path = get_logical_dest_row (tree_view, &path_down_mode,
7897                                    &drop_append_mode);
7898
7899       if (path == NULL)
7900         suggested_action = 0;
7901       else if (path_down_mode)
7902         gtk_tree_path_down (path);
7903
7904       if (suggested_action)
7905         {
7906           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7907                                                      path,
7908                                                      selection_data))
7909             {
7910               if (path_down_mode)
7911                 {
7912                   path_down_mode = FALSE;
7913                   gtk_tree_path_up (path);
7914
7915                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7916                                                              path,
7917                                                              selection_data))
7918                     suggested_action = 0;
7919                 }
7920               else
7921                 suggested_action = 0;
7922             }
7923         }
7924
7925       gdk_drag_status (context, suggested_action, time);
7926
7927       if (path)
7928         gtk_tree_path_free (path);
7929
7930       /* If you can't drop, remove user drop indicator until the next motion */
7931       if (suggested_action == 0)
7932         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7933                                          NULL,
7934                                          GTK_TREE_VIEW_DROP_BEFORE);
7935
7936       return;
7937     }
7938
7939   dest_row = get_dest_row (context, &path_down_mode);
7940
7941   if (dest_row == NULL)
7942     return;
7943
7944   if (gtk_selection_data_get_length (selection_data) >= 0)
7945     {
7946       if (path_down_mode)
7947         {
7948           gtk_tree_path_down (dest_row);
7949           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7950                                                      dest_row, selection_data))
7951             gtk_tree_path_up (dest_row);
7952         }
7953     }
7954
7955   if (gtk_selection_data_get_length (selection_data) >= 0)
7956     {
7957       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
7958                                                  dest_row,
7959                                                  selection_data))
7960         accepted = TRUE;
7961     }
7962
7963   gtk_drag_finish (context,
7964                    accepted,
7965                    (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
7966                    time);
7967
7968   if (gtk_tree_path_get_depth (dest_row) == 1 &&
7969       gtk_tree_path_get_indices (dest_row)[0] == 0 &&
7970       gtk_tree_model_iter_n_children (tree_view->priv->model, NULL) != 0)
7971     {
7972       /* special special case drag to "0", scroll to first item */
7973       if (!tree_view->priv->scroll_to_path)
7974         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
7975     }
7976
7977   gtk_tree_path_free (dest_row);
7978
7979   /* drop dest_row */
7980   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
7981 }
7982
7983
7984
7985 /* GtkContainer Methods
7986  */
7987
7988
7989 static void
7990 gtk_tree_view_remove (GtkContainer *container,
7991                       GtkWidget    *widget)
7992 {
7993   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7994   GtkTreeViewChild *child = NULL;
7995   GList *tmp_list;
7996
7997   tmp_list = tree_view->priv->children;
7998   while (tmp_list)
7999     {
8000       child = tmp_list->data;
8001       if (child->widget == widget)
8002         {
8003           gtk_widget_unparent (widget);
8004
8005           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
8006           g_list_free_1 (tmp_list);
8007           g_slice_free (GtkTreeViewChild, child);
8008           return;
8009         }
8010
8011       tmp_list = tmp_list->next;
8012     }
8013
8014   tmp_list = tree_view->priv->columns;
8015
8016   while (tmp_list)
8017     {
8018       GtkTreeViewColumn *column;
8019       GtkWidget         *button;
8020
8021       column = tmp_list->data;
8022       button = gtk_tree_view_column_get_button (column);
8023
8024       if (button == widget)
8025         {
8026           gtk_widget_unparent (widget);
8027           return;
8028         }
8029       tmp_list = tmp_list->next;
8030     }
8031 }
8032
8033 static void
8034 gtk_tree_view_forall (GtkContainer *container,
8035                       gboolean      include_internals,
8036                       GtkCallback   callback,
8037                       gpointer      callback_data)
8038 {
8039   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8040   GtkTreeViewChild *child = NULL;
8041   GtkTreeViewColumn *column;
8042   GtkWidget *button;
8043   GList *tmp_list;
8044
8045   tmp_list = tree_view->priv->children;
8046   while (tmp_list)
8047     {
8048       child = tmp_list->data;
8049       tmp_list = tmp_list->next;
8050
8051       (* callback) (child->widget, callback_data);
8052     }
8053   if (include_internals == FALSE)
8054     return;
8055
8056   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8057     {
8058       column = tmp_list->data;
8059       button = gtk_tree_view_column_get_button (column);
8060
8061       if (button)
8062         (* callback) (button, callback_data);
8063     }
8064 }
8065
8066 /* Returns TRUE is any of the columns contains a cell that can-focus.
8067  * If this is not the case, a column-spanning focus rectangle will be
8068  * drawn.
8069  */
8070 static gboolean
8071 gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view)
8072 {
8073   GList *list;
8074
8075   for (list = tree_view->priv->columns; list; list = list->next)
8076     {
8077       GtkTreeViewColumn *column = list->data;
8078
8079       if (!gtk_tree_view_column_get_visible (column))
8080         continue;
8081       if (gtk_cell_area_is_activatable (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column))))
8082         return TRUE;
8083     }
8084
8085   return FALSE;
8086 }
8087
8088 static void
8089 column_sizing_notify (GObject    *object,
8090                       GParamSpec *pspec,
8091                       gpointer    data)
8092 {
8093   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
8094
8095   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
8096     /* disable fixed height mode */
8097     g_object_set (data, "fixed-height-mode", FALSE, NULL);
8098 }
8099
8100 /**
8101  * gtk_tree_view_set_fixed_height_mode:
8102  * @tree_view: a #GtkTreeView
8103  * @enable: %TRUE to enable fixed height mode
8104  *
8105  * Enables or disables the fixed height mode of @tree_view.
8106  * Fixed height mode speeds up #GtkTreeView by assuming that all
8107  * rows have the same height.
8108  * Only enable this option if all rows are the same height and all
8109  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
8110  *
8111  * Since: 2.6
8112  **/
8113 void
8114 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
8115                                      gboolean     enable)
8116 {
8117   GList *l;
8118
8119   enable = enable != FALSE;
8120
8121   if (enable == tree_view->priv->fixed_height_mode)
8122     return;
8123
8124   if (!enable)
8125     {
8126       tree_view->priv->fixed_height_mode = 0;
8127       tree_view->priv->fixed_height = -1;
8128     }
8129   else
8130     {
8131       /* make sure all columns are of type FIXED */
8132       for (l = tree_view->priv->columns; l; l = l->next)
8133         {
8134           GtkTreeViewColumn *c = l->data;
8135
8136           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
8137         }
8138
8139       /* yes, we really have to do this is in a separate loop */
8140       for (l = tree_view->priv->columns; l; l = l->next)
8141         g_signal_connect (l->data, "notify::sizing",
8142                           G_CALLBACK (column_sizing_notify), tree_view);
8143
8144       tree_view->priv->fixed_height_mode = 1;
8145       tree_view->priv->fixed_height = -1;
8146     }
8147
8148   /* force a revalidation */
8149   install_presize_handler (tree_view);
8150
8151   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
8152 }
8153
8154 /**
8155  * gtk_tree_view_get_fixed_height_mode:
8156  * @tree_view: a #GtkTreeView
8157  *
8158  * Returns whether fixed height mode is turned on for @tree_view.
8159  *
8160  * Return value: %TRUE if @tree_view is in fixed height mode
8161  *
8162  * Since: 2.6
8163  **/
8164 gboolean
8165 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
8166 {
8167   return tree_view->priv->fixed_height_mode;
8168 }
8169
8170 /* Returns TRUE if the focus is within the headers, after the focus operation is
8171  * done
8172  */
8173 static gboolean
8174 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
8175                             GtkDirectionType  dir,
8176                             gboolean          clamp_column_visible)
8177 {
8178   GtkTreeViewColumn *column;
8179   GtkWidget *focus_child;
8180   GtkWidget *button;
8181   GList *last_column, *first_column;
8182   GList *tmp_list;
8183   gboolean rtl;
8184
8185   if (! tree_view->priv->headers_visible)
8186     return FALSE;
8187
8188   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
8189
8190   first_column = tree_view->priv->columns;
8191   while (first_column)
8192     {
8193       column = GTK_TREE_VIEW_COLUMN (first_column->data);
8194       button = gtk_tree_view_column_get_button (column);
8195
8196       if (gtk_widget_get_can_focus (button) &&
8197           gtk_tree_view_column_get_visible (column) &&
8198           (gtk_tree_view_column_get_clickable (column) ||
8199            gtk_tree_view_column_get_reorderable (column)))
8200         break;
8201       first_column = first_column->next;
8202     }
8203
8204   /* No headers are visible, or are focusable.  We can't focus in or out.
8205    */
8206   if (first_column == NULL)
8207     return FALSE;
8208
8209   last_column = g_list_last (tree_view->priv->columns);
8210   while (last_column)
8211     {
8212       column = GTK_TREE_VIEW_COLUMN (last_column->data);
8213       button = gtk_tree_view_column_get_button (column);
8214
8215       if (gtk_widget_get_can_focus (button) &&
8216           gtk_tree_view_column_get_visible (column) &&
8217           (gtk_tree_view_column_get_clickable (column) ||
8218            gtk_tree_view_column_get_reorderable (column)))
8219         break;
8220       last_column = last_column->prev;
8221     }
8222
8223
8224   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8225
8226   switch (dir)
8227     {
8228     case GTK_DIR_TAB_BACKWARD:
8229     case GTK_DIR_TAB_FORWARD:
8230     case GTK_DIR_UP:
8231     case GTK_DIR_DOWN:
8232       if (focus_child == NULL)
8233         {
8234           if (tree_view->priv->focus_column != NULL)
8235             button = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8236           else
8237             button = NULL;
8238
8239           if (button && gtk_widget_get_can_focus (button))
8240             focus_child = button;
8241           else
8242             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8243
8244           gtk_widget_grab_focus (focus_child);
8245           break;
8246         }
8247       return FALSE;
8248
8249     case GTK_DIR_LEFT:
8250     case GTK_DIR_RIGHT:
8251       if (focus_child == NULL)
8252         {
8253           if (tree_view->priv->focus_column != NULL)
8254             focus_child = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8255           else if (dir == GTK_DIR_LEFT)
8256             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (last_column->data));
8257           else
8258             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8259
8260           gtk_widget_grab_focus (focus_child);
8261           break;
8262         }
8263
8264       if (gtk_widget_child_focus (focus_child, dir))
8265         {
8266           /* The focus moves inside the button. */
8267           /* This is probably a great example of bad UI */
8268           break;
8269         }
8270
8271       /* We need to move the focus among the row of buttons. */
8272       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8273         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8274           break;
8275
8276       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
8277           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
8278         {
8279           gtk_widget_error_bell (GTK_WIDGET (tree_view));
8280           break;
8281         }
8282
8283       while (tmp_list)
8284         {
8285           GtkTreeViewColumn *column;
8286           GtkWidget         *button;
8287
8288           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
8289             tmp_list = tmp_list->next;
8290           else
8291             tmp_list = tmp_list->prev;
8292
8293           if (tmp_list == NULL)
8294             {
8295               g_warning ("Internal button not found");
8296               break;
8297             }
8298           column = tmp_list->data;
8299           button = gtk_tree_view_column_get_button (column);
8300           if (button &&
8301               gtk_tree_view_column_get_visible (column) &&
8302               gtk_widget_get_can_focus (button))
8303             {
8304               focus_child = button;
8305               gtk_widget_grab_focus (button);
8306               break;
8307             }
8308         }
8309       break;
8310     default:
8311       g_assert_not_reached ();
8312       break;
8313     }
8314
8315   /* if focus child is non-null, we assume it's been set to the current focus child
8316    */
8317   if (focus_child)
8318     {
8319       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8320         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8321           {
8322             _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (tmp_list->data));
8323             break;
8324           }
8325
8326       if (clamp_column_visible)
8327         {
8328           gtk_tree_view_clamp_column_visible (tree_view,
8329                                               tree_view->priv->focus_column,
8330                                               FALSE);
8331         }
8332     }
8333
8334   return (focus_child != NULL);
8335 }
8336
8337 /* This function returns in 'path' the first focusable path, if the given path
8338  * is already focusable, it's the returned one.
8339  */
8340 static gboolean
8341 search_first_focusable_path (GtkTreeView  *tree_view,
8342                              GtkTreePath **path,
8343                              gboolean      search_forward,
8344                              GtkRBTree   **new_tree,
8345                              GtkRBNode   **new_node)
8346 {
8347   GtkRBTree *tree = NULL;
8348   GtkRBNode *node = NULL;
8349
8350   if (!path || !*path)
8351     return FALSE;
8352
8353   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
8354
8355   if (!tree || !node)
8356     return FALSE;
8357
8358   while (node && row_is_separator (tree_view, NULL, *path))
8359     {
8360       if (search_forward)
8361         _gtk_rbtree_next_full (tree, node, &tree, &node);
8362       else
8363         _gtk_rbtree_prev_full (tree, node, &tree, &node);
8364
8365       if (*path)
8366         gtk_tree_path_free (*path);
8367
8368       if (node)
8369         *path = _gtk_tree_path_new_from_rbtree (tree, node);
8370       else
8371         *path = NULL;
8372     }
8373
8374   if (new_tree)
8375     *new_tree = tree;
8376
8377   if (new_node)
8378     *new_node = node;
8379
8380   return (*path != NULL);
8381 }
8382
8383 static gint
8384 gtk_tree_view_focus (GtkWidget        *widget,
8385                      GtkDirectionType  direction)
8386 {
8387   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8388   GtkContainer *container = GTK_CONTAINER (widget);
8389   GtkWidget *focus_child;
8390
8391   if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
8392     return FALSE;
8393
8394   focus_child = gtk_container_get_focus_child (container);
8395
8396   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
8397   /* Case 1.  Headers currently have focus. */
8398   if (focus_child)
8399     {
8400       switch (direction)
8401         {
8402         case GTK_DIR_LEFT:
8403         case GTK_DIR_RIGHT:
8404           gtk_tree_view_header_focus (tree_view, direction, TRUE);
8405           return TRUE;
8406         case GTK_DIR_TAB_BACKWARD:
8407         case GTK_DIR_UP:
8408           return FALSE;
8409         case GTK_DIR_TAB_FORWARD:
8410         case GTK_DIR_DOWN:
8411           gtk_widget_grab_focus (widget);
8412           return TRUE;
8413         default:
8414           g_assert_not_reached ();
8415           return FALSE;
8416         }
8417     }
8418
8419   /* Case 2. We don't have focus at all. */
8420   if (!gtk_widget_has_focus (widget))
8421     {
8422       gtk_widget_grab_focus (widget);
8423       return TRUE;
8424     }
8425
8426   /* Case 3. We have focus already. */
8427   if (direction == GTK_DIR_TAB_BACKWARD)
8428     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
8429   else if (direction == GTK_DIR_TAB_FORWARD)
8430     return FALSE;
8431
8432   /* Other directions caught by the keybindings */
8433   gtk_widget_grab_focus (widget);
8434   return TRUE;
8435 }
8436
8437 static void
8438 gtk_tree_view_grab_focus (GtkWidget *widget)
8439 {
8440   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
8441
8442   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
8443 }
8444
8445 static void
8446 gtk_tree_view_style_updated (GtkWidget *widget)
8447 {
8448   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8449   GList *list;
8450   GtkTreeViewColumn *column;
8451   GtkStyleContext *style_context;
8452   const GtkBitmask *changes;
8453
8454   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->style_updated (widget);
8455
8456   if (gtk_widget_get_realized (widget))
8457     {
8458       gtk_tree_view_ensure_background (tree_view);
8459
8460       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
8461       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
8462     }
8463
8464   style_context = gtk_widget_get_style_context (widget);
8465   changes = _gtk_style_context_get_changes (style_context);
8466   if (changes == NULL || _gtk_css_style_property_changes_affect_size (changes))
8467     {
8468       for (list = tree_view->priv->columns; list; list = list->next)
8469         {
8470           column = list->data;
8471           _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8472         }
8473
8474       tree_view->priv->fixed_height = -1;
8475       _gtk_rbtree_mark_invalid (tree_view->priv->tree);
8476     }
8477 }
8478
8479
8480 static void
8481 gtk_tree_view_set_focus_child (GtkContainer *container,
8482                                GtkWidget    *child)
8483 {
8484   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8485   GList *list;
8486
8487   for (list = tree_view->priv->columns; list; list = list->next)
8488     {
8489       if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child)
8490         {
8491           _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
8492           break;
8493         }
8494     }
8495
8496   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
8497 }
8498
8499 static GtkWidgetPath *
8500 gtk_tree_view_get_path_for_child (GtkContainer *container,
8501                                   GtkWidget    *child)
8502 {
8503   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8504   GtkWidgetPath *path;
8505   gboolean rtl;
8506   GList *list, *visible_columns = NULL;
8507   gint n_col = 0;
8508
8509   path = GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->get_path_for_child (container, child);
8510   rtl = (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL);
8511
8512   for (list = tree_view->priv->columns; list; list = list->next)
8513     {
8514       GtkTreeViewColumn *column = list->data;
8515
8516       if (gtk_tree_view_column_get_visible (column))
8517         visible_columns = g_list_prepend (visible_columns, column);
8518     }
8519
8520   if (!rtl)
8521     visible_columns = g_list_reverse (visible_columns);
8522
8523   for (list = visible_columns; list != NULL; list = list->next)
8524     {
8525       GtkTreeViewColumn *column = list->data;
8526       GtkRegionFlags flags = 0;
8527
8528       n_col++;
8529
8530       if (gtk_tree_view_column_get_widget (column) != child &&
8531           gtk_tree_view_column_get_button (column) != child)
8532         continue;
8533
8534       if ((n_col % 2) == 0)
8535         flags |= GTK_REGION_EVEN;
8536       else
8537         flags |= GTK_REGION_ODD;
8538
8539       if (n_col == 1)
8540         flags |= GTK_REGION_FIRST;
8541
8542       if (!list->next)
8543         flags |= GTK_REGION_LAST;
8544
8545       gtk_widget_path_iter_add_region (path, gtk_widget_path_length (path) - 2, GTK_STYLE_REGION_COLUMN_HEADER, flags);
8546       break;
8547     }
8548   g_list_free (visible_columns);
8549
8550   return path;
8551 }
8552
8553 static gboolean
8554 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8555                                 GtkMovementStep    step,
8556                                 gint               count)
8557 {
8558   GdkModifierType state;
8559
8560   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8561   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8562                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8563                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8564                         step == GTK_MOVEMENT_PAGES ||
8565                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8566
8567   if (tree_view->priv->tree == NULL)
8568     return FALSE;
8569   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8570     return FALSE;
8571
8572   gtk_tree_view_stop_editing (tree_view, FALSE);
8573   tree_view->priv->draw_keyfocus = TRUE;
8574   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8575
8576   if (gtk_get_current_event_state (&state))
8577     {
8578       GdkModifierType extend_mod_mask;
8579       GdkModifierType modify_mod_mask;
8580
8581       extend_mod_mask =
8582         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8583                                       GDK_MODIFIER_INTENT_EXTEND_SELECTION);
8584
8585       modify_mod_mask =
8586         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8587                                       GDK_MODIFIER_INTENT_MODIFY_SELECTION);
8588
8589       if ((state & modify_mod_mask) == modify_mod_mask)
8590         tree_view->priv->modify_selection_pressed = TRUE;
8591       if ((state & extend_mod_mask) == extend_mod_mask)
8592         tree_view->priv->extend_selection_pressed = TRUE;
8593     }
8594   /* else we assume not pressed */
8595
8596   switch (step)
8597     {
8598       /* currently we make no distinction.  When we go bi-di, we need to */
8599     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8600     case GTK_MOVEMENT_VISUAL_POSITIONS:
8601       gtk_tree_view_move_cursor_left_right (tree_view, count);
8602       break;
8603     case GTK_MOVEMENT_DISPLAY_LINES:
8604       gtk_tree_view_move_cursor_up_down (tree_view, count);
8605       break;
8606     case GTK_MOVEMENT_PAGES:
8607       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8608       break;
8609     case GTK_MOVEMENT_BUFFER_ENDS:
8610       gtk_tree_view_move_cursor_start_end (tree_view, count);
8611       break;
8612     default:
8613       g_assert_not_reached ();
8614     }
8615
8616   tree_view->priv->modify_selection_pressed = FALSE;
8617   tree_view->priv->extend_selection_pressed = FALSE;
8618
8619   return TRUE;
8620 }
8621
8622 static void
8623 gtk_tree_view_put (GtkTreeView *tree_view,
8624                    GtkWidget   *child_widget,
8625                    /* in bin_window coordinates */
8626                    gint         x,
8627                    gint         y,
8628                    gint         width,
8629                    gint         height)
8630 {
8631   GtkTreeViewChild *child;
8632
8633   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8634   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8635
8636   child = g_slice_new (GtkTreeViewChild);
8637
8638   child->widget = child_widget;
8639   child->x = x;
8640   child->y = y;
8641   child->width = width;
8642   child->height = height;
8643
8644   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8645
8646   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8647     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8648
8649   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8650 }
8651
8652 void
8653 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8654                                   GtkWidget   *widget,
8655                                   /* in tree coordinates */
8656                                   gint         x,
8657                                   gint         y,
8658                                   gint         width,
8659                                   gint         height)
8660 {
8661   GtkTreeViewChild *child = NULL;
8662   GList *list;
8663   GdkRectangle allocation;
8664
8665   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8666   g_return_if_fail (GTK_IS_WIDGET (widget));
8667
8668   for (list = tree_view->priv->children; list; list = list->next)
8669     {
8670       if (((GtkTreeViewChild *)list->data)->widget == widget)
8671         {
8672           child = list->data;
8673           break;
8674         }
8675     }
8676   if (child == NULL)
8677     return;
8678
8679   allocation.x = child->x = x;
8680   allocation.y = child->y = y;
8681   allocation.width = child->width = width;
8682   allocation.height = child->height = height;
8683
8684   if (gtk_widget_get_realized (widget))
8685     gtk_widget_size_allocate (widget, &allocation);
8686 }
8687
8688
8689 /* TreeModel Callbacks
8690  */
8691
8692 static void
8693 gtk_tree_view_row_changed (GtkTreeModel *model,
8694                            GtkTreePath  *path,
8695                            GtkTreeIter  *iter,
8696                            gpointer      data)
8697 {
8698   GtkTreeView *tree_view = (GtkTreeView *)data;
8699   GtkRBTree *tree;
8700   GtkRBNode *node;
8701   gboolean free_path = FALSE;
8702   GList *list;
8703   GtkTreePath *cursor_path;
8704
8705   g_return_if_fail (path != NULL || iter != NULL);
8706
8707   if (tree_view->priv->cursor_node != NULL)
8708     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
8709                                                   tree_view->priv->cursor_node);
8710   else
8711     cursor_path = NULL;
8712
8713   if (tree_view->priv->edited_column &&
8714       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8715     gtk_tree_view_stop_editing (tree_view, TRUE);
8716
8717   if (cursor_path != NULL)
8718     gtk_tree_path_free (cursor_path);
8719
8720   if (path == NULL)
8721     {
8722       path = gtk_tree_model_get_path (model, iter);
8723       free_path = TRUE;
8724     }
8725   else if (iter == NULL)
8726     gtk_tree_model_get_iter (model, iter, path);
8727
8728   if (_gtk_tree_view_find_node (tree_view,
8729                                 path,
8730                                 &tree,
8731                                 &node))
8732     /* We aren't actually showing the node */
8733     goto done;
8734
8735   if (tree == NULL)
8736     goto done;
8737
8738   _gtk_tree_view_accessible_changed (tree_view, tree, node);
8739
8740   if (tree_view->priv->fixed_height_mode
8741       && tree_view->priv->fixed_height >= 0)
8742     {
8743       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8744       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8745         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8746     }
8747   else
8748     {
8749       _gtk_rbtree_node_mark_invalid (tree, node);
8750       for (list = tree_view->priv->columns; list; list = list->next)
8751         {
8752           GtkTreeViewColumn *column;
8753
8754           column = list->data;
8755           if (!gtk_tree_view_column_get_visible (column))
8756             continue;
8757
8758           if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8759             {
8760               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8761             }
8762         }
8763     }
8764
8765  done:
8766   if (!tree_view->priv->fixed_height_mode &&
8767       gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8768     install_presize_handler (tree_view);
8769   if (free_path)
8770     gtk_tree_path_free (path);
8771 }
8772
8773 static void
8774 gtk_tree_view_row_inserted (GtkTreeModel *model,
8775                             GtkTreePath  *path,
8776                             GtkTreeIter  *iter,
8777                             gpointer      data)
8778 {
8779   GtkTreeView *tree_view = (GtkTreeView *) data;
8780   gint *indices;
8781   GtkRBTree *tree;
8782   GtkRBNode *tmpnode = NULL;
8783   gint depth;
8784   gint i = 0;
8785   gint height;
8786   gboolean free_path = FALSE;
8787   gboolean node_visible = TRUE;
8788
8789   g_return_if_fail (path != NULL || iter != NULL);
8790
8791   if (tree_view->priv->fixed_height_mode
8792       && tree_view->priv->fixed_height >= 0)
8793     height = tree_view->priv->fixed_height;
8794   else
8795     height = 0;
8796
8797   if (path == NULL)
8798     {
8799       path = gtk_tree_model_get_path (model, iter);
8800       free_path = TRUE;
8801     }
8802   else if (iter == NULL)
8803     gtk_tree_model_get_iter (model, iter, path);
8804
8805   if (tree_view->priv->tree == NULL)
8806     tree_view->priv->tree = _gtk_rbtree_new ();
8807
8808   tree = tree_view->priv->tree;
8809
8810   /* Update all row-references */
8811   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8812   depth = gtk_tree_path_get_depth (path);
8813   indices = gtk_tree_path_get_indices (path);
8814
8815   /* First, find the parent tree */
8816   while (i < depth - 1)
8817     {
8818       if (tree == NULL)
8819         {
8820           /* We aren't showing the node */
8821           node_visible = FALSE;
8822           goto done;
8823         }
8824
8825       tmpnode = _gtk_rbtree_find_count (tree, indices[i] + 1);
8826       if (tmpnode == NULL)
8827         {
8828           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8829                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8830                      "before the parent was inserted.");
8831           goto done;
8832         }
8833       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8834         {
8835           /* FIXME enforce correct behavior on model, probably */
8836           /* In theory, the model should have emitted has_child_toggled here.  We
8837            * try to catch it anyway, just to be safe, in case the model hasn't.
8838            */
8839           GtkTreePath *tmppath = _gtk_tree_path_new_from_rbtree (tree, tmpnode);
8840           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8841           gtk_tree_path_free (tmppath);
8842           goto done;
8843         }
8844
8845       tree = tmpnode->children;
8846       i++;
8847     }
8848
8849   if (tree == NULL)
8850     {
8851       node_visible = FALSE;
8852       goto done;
8853     }
8854
8855   /* ref the node */
8856   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8857   if (indices[depth - 1] == 0)
8858     {
8859       tmpnode = _gtk_rbtree_find_count (tree, 1);
8860       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8861     }
8862   else
8863     {
8864       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8865       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8866     }
8867
8868   _gtk_tree_view_accessible_add (tree_view, tree, tmpnode);
8869
8870  done:
8871   if (height > 0)
8872     {
8873       if (tree)
8874         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8875
8876       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8877         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8878       else
8879         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8880     }
8881   else
8882     install_presize_handler (tree_view);
8883   if (free_path)
8884     gtk_tree_path_free (path);
8885 }
8886
8887 static void
8888 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8889                                      GtkTreePath  *path,
8890                                      GtkTreeIter  *iter,
8891                                      gpointer      data)
8892 {
8893   GtkTreeView *tree_view = (GtkTreeView *)data;
8894   GtkTreeIter real_iter;
8895   gboolean has_child;
8896   GtkRBTree *tree;
8897   GtkRBNode *node;
8898   gboolean free_path = FALSE;
8899
8900   g_return_if_fail (path != NULL || iter != NULL);
8901
8902   if (iter)
8903     real_iter = *iter;
8904
8905   if (path == NULL)
8906     {
8907       path = gtk_tree_model_get_path (model, iter);
8908       free_path = TRUE;
8909     }
8910   else if (iter == NULL)
8911     gtk_tree_model_get_iter (model, &real_iter, path);
8912
8913   if (_gtk_tree_view_find_node (tree_view,
8914                                 path,
8915                                 &tree,
8916                                 &node))
8917     /* We aren't actually showing the node */
8918     goto done;
8919
8920   if (tree == NULL)
8921     goto done;
8922
8923   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8924   /* Sanity check.
8925    */
8926   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8927     goto done;
8928
8929   if (has_child)
8930     {
8931       GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8932       _gtk_tree_view_accessible_add_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8933     }
8934   else
8935     {
8936       GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8937       _gtk_tree_view_accessible_remove_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8938     }
8939
8940   if (has_child && tree_view->priv->is_list)
8941     {
8942       tree_view->priv->is_list = FALSE;
8943       if (tree_view->priv->show_expanders)
8944         {
8945           GList *list;
8946
8947           for (list = tree_view->priv->columns; list; list = list->next)
8948             if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
8949               {
8950                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8951                 break;
8952               }
8953         }
8954       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8955     }
8956   else
8957     {
8958       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8959     }
8960
8961  done:
8962   if (free_path)
8963     gtk_tree_path_free (path);
8964 }
8965
8966 static void
8967 count_children_helper (GtkRBTree *tree,
8968                        GtkRBNode *node,
8969                        gpointer   data)
8970 {
8971   if (node->children)
8972     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8973   (*((gint *)data))++;
8974 }
8975
8976 static void
8977 check_selection_helper (GtkRBTree *tree,
8978                         GtkRBNode *node,
8979                         gpointer   data)
8980 {
8981   gint *value = (gint *)data;
8982
8983   *value |= GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8984
8985   if (node->children && !*value)
8986     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8987 }
8988
8989 static void
8990 gtk_tree_view_row_deleted (GtkTreeModel *model,
8991                            GtkTreePath  *path,
8992                            gpointer      data)
8993 {
8994   GtkTreeView *tree_view = (GtkTreeView *)data;
8995   GtkRBTree *tree;
8996   GtkRBNode *node;
8997   GList *list;
8998   gboolean selection_changed = FALSE, cursor_changed = FALSE;
8999   GtkRBTree *cursor_tree = NULL;
9000   GtkRBNode *cursor_node = NULL;
9001
9002   g_return_if_fail (path != NULL);
9003
9004   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
9005
9006   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
9007     return;
9008
9009   if (tree == NULL)
9010     return;
9011
9012   /* check if the selection has been changed */
9013   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
9014                         check_selection_helper, &selection_changed);
9015
9016   for (list = tree_view->priv->columns; list; list = list->next)
9017     if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)) &&
9018         gtk_tree_view_column_get_sizing (GTK_TREE_VIEW_COLUMN (list->data)) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9019       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
9020
9021   /* Ensure we don't have a dangling pointer to a dead node */
9022   ensure_unprelighted (tree_view);
9023
9024   /* Cancel editting if we've started */
9025   gtk_tree_view_stop_editing (tree_view, TRUE);
9026
9027   /* If the cursor row got deleted, move the cursor to the next row */
9028   if (tree_view->priv->cursor_node &&
9029       (tree_view->priv->cursor_node == node ||
9030        (node->children && (tree_view->priv->cursor_tree == node->children ||
9031                            _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree)))))
9032     {
9033       GtkTreePath *cursor_path;
9034
9035       cursor_tree = tree;
9036       cursor_node = _gtk_rbtree_next (tree, node);
9037       /* find the first node that is not going to be deleted */
9038       while (cursor_node == NULL && cursor_tree->parent_tree)
9039         {
9040           cursor_node = _gtk_rbtree_next (cursor_tree->parent_tree,
9041                                           cursor_tree->parent_node);
9042           cursor_tree = cursor_tree->parent_tree;
9043         }
9044
9045       if (cursor_node != NULL)
9046         cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9047       else
9048         cursor_path = NULL;
9049
9050       if (cursor_path == NULL ||
9051           ! search_first_focusable_path (tree_view, &cursor_path, TRUE,
9052                                          &cursor_tree, &cursor_node))
9053         {
9054           /* It looks like we reached the end of the view without finding
9055            * a focusable row.  We will step backwards to find the last
9056            * focusable row.
9057            */
9058           _gtk_rbtree_prev_full (tree, node, &cursor_tree, &cursor_node);
9059           if (cursor_node)
9060             {
9061               cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9062               if (! search_first_focusable_path (tree_view, &cursor_path, FALSE,
9063                                                  &cursor_tree, &cursor_node))
9064                 cursor_node = NULL;
9065               gtk_tree_path_free (cursor_path);
9066             }
9067         }
9068       else if (cursor_path)
9069         gtk_tree_path_free (cursor_path);
9070
9071       cursor_changed = TRUE;
9072     }
9073
9074   if (tree_view->priv->destroy_count_func)
9075     {
9076       gint child_count = 0;
9077       if (node->children)
9078         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
9079       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
9080     }
9081
9082   if (tree->root->count == 1)
9083     {
9084       if (tree_view->priv->tree == tree)
9085         tree_view->priv->tree = NULL;
9086
9087       _gtk_tree_view_accessible_remove_state (tree_view,
9088                                               tree->parent_tree, tree->parent_node,
9089                                               GTK_CELL_RENDERER_EXPANDED);
9090       _gtk_tree_view_accessible_remove (tree_view, tree, NULL);
9091       _gtk_rbtree_remove (tree);
9092     }
9093   else
9094     {
9095       _gtk_tree_view_accessible_remove (tree_view, tree, node);
9096       _gtk_rbtree_remove_node (tree, node);
9097     }
9098
9099   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
9100     {
9101       gtk_tree_row_reference_free (tree_view->priv->top_row);
9102       tree_view->priv->top_row = NULL;
9103     }
9104
9105   install_scroll_sync_handler (tree_view);
9106
9107   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9108
9109   if (cursor_changed)
9110     {
9111       if (cursor_node)
9112         {
9113           GtkTreePath *cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9114           gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CURSOR_INVALID);
9115           gtk_tree_path_free (cursor_path);
9116         }
9117       else
9118         gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT | CURSOR_INVALID);
9119     }
9120   if (selection_changed)
9121     g_signal_emit_by_name (tree_view->priv->selection, "changed");
9122 }
9123
9124 static void
9125 gtk_tree_view_rows_reordered (GtkTreeModel *model,
9126                               GtkTreePath  *parent,
9127                               GtkTreeIter  *iter,
9128                               gint         *new_order,
9129                               gpointer      data)
9130 {
9131   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
9132   GtkRBTree *tree;
9133   GtkRBNode *node;
9134   gint len;
9135
9136   len = gtk_tree_model_iter_n_children (model, iter);
9137
9138   if (len < 2)
9139     return;
9140
9141   gtk_tree_row_reference_reordered (G_OBJECT (data),
9142                                     parent,
9143                                     iter,
9144                                     new_order);
9145
9146   if (_gtk_tree_view_find_node (tree_view,
9147                                 parent,
9148                                 &tree,
9149                                 &node))
9150     return;
9151
9152   /* We need to special case the parent path */
9153   if (tree == NULL)
9154     tree = tree_view->priv->tree;
9155   else
9156     tree = node->children;
9157
9158   if (tree == NULL)
9159     return;
9160
9161   if (tree_view->priv->edited_column)
9162     gtk_tree_view_stop_editing (tree_view, TRUE);
9163
9164   /* we need to be unprelighted */
9165   ensure_unprelighted (tree_view);
9166
9167   _gtk_rbtree_reorder (tree, new_order, len);
9168
9169   _gtk_tree_view_accessible_reorder (tree_view);
9170
9171   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
9172
9173   gtk_tree_view_dy_to_top_row (tree_view);
9174 }
9175
9176
9177 /* Internal tree functions
9178  */
9179
9180
9181 static void
9182 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
9183                                      GtkRBTree         *tree,
9184                                      GtkTreeViewColumn *column,
9185                                      gint              *x1,
9186                                      gint              *x2)
9187 {
9188   GtkTreeViewColumn *tmp_column = NULL;
9189   gint total_width;
9190   GList *list;
9191   gboolean rtl;
9192
9193   if (x1)
9194     *x1 = 0;
9195
9196   if (x2)
9197     *x2 = 0;
9198
9199   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9200
9201   total_width = 0;
9202   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9203        list;
9204        list = (rtl ? list->prev : list->next))
9205     {
9206       tmp_column = list->data;
9207
9208       if (tmp_column == column)
9209         break;
9210
9211       if (gtk_tree_view_column_get_visible (tmp_column))
9212         total_width += gtk_tree_view_column_get_width (tmp_column);
9213     }
9214
9215   if (tmp_column != column)
9216     {
9217       g_warning (G_STRLOC": passed-in column isn't in the tree");
9218       return;
9219     }
9220
9221   if (x1)
9222     *x1 = total_width;
9223
9224   if (x2)
9225     {
9226       if (gtk_tree_view_column_get_visible (column))
9227         *x2 = total_width + gtk_tree_view_column_get_width (column);
9228       else
9229         *x2 = total_width; /* width of 0 */
9230     }
9231 }
9232
9233 static void
9234 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
9235                                 GtkRBTree   *tree,
9236                                 gint        *x1,
9237                                 gint        *x2)
9238 {
9239   gint x_offset = 0;
9240   GList *list;
9241   GtkTreeViewColumn *tmp_column = NULL;
9242   gint total_width;
9243   gint expander_size, expander_render_size;
9244   gint horizontal_separator;
9245   gboolean indent_expanders;
9246   gboolean rtl;
9247
9248   gtk_widget_style_get (GTK_WIDGET (tree_view),
9249                         "indent-expanders", &indent_expanders,
9250                         "horizontal-separator", &horizontal_separator,
9251                         NULL);
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   expander_render_size = expander_size - (horizontal_separator / 2);
9256
9257   total_width = 0;
9258   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9259        list;
9260        list = (rtl ? list->prev : list->next))
9261     {
9262       tmp_column = list->data;
9263
9264       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
9265         {
9266           if (rtl)
9267             x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - expander_size;
9268           else
9269             x_offset = total_width;
9270           break;
9271         }
9272
9273       if (gtk_tree_view_column_get_visible (tmp_column))
9274         total_width += gtk_tree_view_column_get_width (tmp_column);
9275     }
9276
9277   x_offset += (expander_size - expander_render_size);
9278
9279   if (indent_expanders)
9280     {
9281       if (rtl)
9282         x_offset -= expander_size * _gtk_rbtree_get_depth (tree);
9283       else
9284         x_offset += expander_size * _gtk_rbtree_get_depth (tree);
9285     }
9286
9287   *x1 = x_offset;
9288
9289   if (tmp_column &&
9290       gtk_tree_view_column_get_visible (tmp_column))
9291     /* +1 because x2 isn't included in the range. */
9292     *x2 = *x1 + expander_render_size + 1;
9293   else
9294     *x2 = *x1;
9295 }
9296
9297 static void
9298 gtk_tree_view_build_tree (GtkTreeView *tree_view,
9299                           GtkRBTree   *tree,
9300                           GtkTreeIter *iter,
9301                           gint         depth,
9302                           gboolean     recurse)
9303 {
9304   GtkRBNode *temp = NULL;
9305   GtkTreePath *path = NULL;
9306
9307   do
9308     {
9309       gtk_tree_model_ref_node (tree_view->priv->model, iter);
9310       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
9311
9312       if (tree_view->priv->fixed_height > 0)
9313         {
9314           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
9315             {
9316               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
9317               _gtk_rbtree_node_mark_valid (tree, temp);
9318             }
9319         }
9320
9321       if (tree_view->priv->is_list)
9322         continue;
9323
9324       if (recurse)
9325         {
9326           GtkTreeIter child;
9327
9328           if (!path)
9329             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
9330           else
9331             gtk_tree_path_next (path);
9332
9333           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
9334             {
9335               gboolean expand;
9336
9337               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
9338
9339               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
9340                   && !expand)
9341                 {
9342                   temp->children = _gtk_rbtree_new ();
9343                   temp->children->parent_tree = tree;
9344                   temp->children->parent_node = temp;
9345                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
9346                 }
9347             }
9348         }
9349
9350       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
9351         {
9352           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
9353             temp->flags ^= GTK_RBNODE_IS_PARENT;
9354         }
9355     }
9356   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
9357
9358   if (path)
9359     gtk_tree_path_free (path);
9360 }
9361
9362 /* Make sure the node is visible vertically */
9363 static void
9364 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
9365                                   GtkRBTree   *tree,
9366                                   GtkRBNode   *node)
9367 {
9368   gint node_dy, height;
9369   GtkTreePath *path = NULL;
9370
9371   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9372     return;
9373
9374   /* just return if the node is visible, avoiding a costly expose */
9375   node_dy = _gtk_rbtree_node_find_offset (tree, node);
9376   height = gtk_tree_view_get_row_height (tree_view, node);
9377   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
9378       && node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment)
9379       && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
9380                               + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
9381     return;
9382
9383   path = _gtk_tree_path_new_from_rbtree (tree, node);
9384   if (path)
9385     {
9386       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
9387       gtk_tree_path_free (path);
9388     }
9389 }
9390
9391 static void
9392 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
9393                                     GtkTreeViewColumn *column,
9394                                     gboolean           focus_to_cell)
9395 {
9396   GtkAllocation allocation;
9397   gint x, width;
9398
9399   if (column == NULL)
9400     return;
9401
9402   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
9403   x = allocation.x;
9404   width = allocation.width;
9405
9406   if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9407     {
9408       /* The column is larger than the horizontal page size.  If the
9409        * column has cells which can be focussed individually, then we make
9410        * sure the cell which gets focus is fully visible (if even the
9411        * focus cell is bigger than the page size, we make sure the
9412        * left-hand side of the cell is visible).
9413        *
9414        * If the column does not have an activatable cell, we
9415        * make sure the left-hand side of the column is visible.
9416        */
9417
9418       if (focus_to_cell && gtk_tree_view_has_can_focus_cell (tree_view))
9419         {
9420           GtkCellArea *cell_area;
9421           GtkCellRenderer *focus_cell;
9422
9423           cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
9424           focus_cell = gtk_cell_area_get_focus_cell (cell_area);
9425
9426           if (gtk_tree_view_column_cell_get_position (column, focus_cell,
9427                                                       &x, &width))
9428             {
9429               if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9430                 {
9431                   if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment) < x + width)
9432                     gtk_adjustment_set_value (tree_view->priv->hadjustment,
9433                                               x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9434                   else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9435                     gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9436                 }
9437             }
9438         }
9439
9440       gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9441     }
9442   else
9443     {
9444       if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
9445           gtk_adjustment_set_value (tree_view->priv->hadjustment,
9446                                     x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9447       else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9448         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9449   }
9450 }
9451
9452 /* This function could be more efficient.  I'll optimize it if profiling seems
9453  * to imply that it is important */
9454 GtkTreePath *
9455 _gtk_tree_path_new_from_rbtree (GtkRBTree   *tree,
9456                                 GtkRBNode   *node)
9457 {
9458   GtkTreePath *path;
9459   GtkRBTree *tmp_tree;
9460   GtkRBNode *tmp_node, *last;
9461   gint count;
9462
9463   path = gtk_tree_path_new ();
9464
9465   g_return_val_if_fail (node != NULL, path);
9466
9467   count = 1 + node->left->count;
9468
9469   last = node;
9470   tmp_node = node->parent;
9471   tmp_tree = tree;
9472   while (tmp_tree)
9473     {
9474       while (!_gtk_rbtree_is_nil (tmp_node))
9475         {
9476           if (tmp_node->right == last)
9477             count += 1 + tmp_node->left->count;
9478           last = tmp_node;
9479           tmp_node = tmp_node->parent;
9480         }
9481       gtk_tree_path_prepend_index (path, count - 1);
9482       last = tmp_tree->parent_node;
9483       tmp_tree = tmp_tree->parent_tree;
9484       if (last)
9485         {
9486           count = 1 + last->left->count;
9487           tmp_node = last->parent;
9488         }
9489     }
9490   return path;
9491 }
9492
9493 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
9494  * invalid (ie. points to a node that's not in the tree), *tree and *node are
9495  * both set to NULL.
9496  */
9497 gboolean
9498 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
9499                           GtkTreePath  *path,
9500                           GtkRBTree   **tree,
9501                           GtkRBNode   **node)
9502 {
9503   GtkRBNode *tmpnode = NULL;
9504   GtkRBTree *tmptree = tree_view->priv->tree;
9505   gint *indices = gtk_tree_path_get_indices (path);
9506   gint depth = gtk_tree_path_get_depth (path);
9507   gint i = 0;
9508
9509   *node = NULL;
9510   *tree = NULL;
9511
9512   if (depth == 0 || tmptree == NULL)
9513     return FALSE;
9514   do
9515     {
9516       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
9517       ++i;
9518       if (tmpnode == NULL)
9519         {
9520           *tree = NULL;
9521           *node = NULL;
9522           return FALSE;
9523         }
9524       if (i >= depth)
9525         {
9526           *tree = tmptree;
9527           *node = tmpnode;
9528           return FALSE;
9529         }
9530       *tree = tmptree;
9531       *node = tmpnode;
9532       tmptree = tmpnode->children;
9533       if (tmptree == NULL)
9534         return TRUE;
9535     }
9536   while (1);
9537 }
9538
9539 static gboolean
9540 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9541                                   GtkTreeViewColumn *column)
9542 {
9543   GList *list;
9544
9545   if (tree_view->priv->is_list)
9546     return FALSE;
9547
9548   if (tree_view->priv->expander_column != NULL)
9549     {
9550       if (tree_view->priv->expander_column == column)
9551         return TRUE;
9552       return FALSE;
9553     }
9554   else
9555     {
9556       for (list = tree_view->priv->columns;
9557            list;
9558            list = list->next)
9559         if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
9560           break;
9561       if (list && list->data == column)
9562         return TRUE;
9563     }
9564   return FALSE;
9565 }
9566
9567 static inline gboolean
9568 gtk_tree_view_draw_expanders (GtkTreeView *tree_view)
9569 {
9570   if (!tree_view->priv->is_list && tree_view->priv->show_expanders)
9571     return TRUE;
9572   /* else */
9573   return FALSE;
9574 }
9575
9576 static void
9577 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9578                                 guint           keyval,
9579                                 guint           modmask,
9580                                 gboolean        add_shifted_binding,
9581                                 GtkMovementStep step,
9582                                 gint            count)
9583 {
9584
9585   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9586                                 "move-cursor", 2,
9587                                 G_TYPE_ENUM, step,
9588                                 G_TYPE_INT, count);
9589
9590   if (add_shifted_binding)
9591     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9592                                   "move-cursor", 2,
9593                                   G_TYPE_ENUM, step,
9594                                   G_TYPE_INT, count);
9595
9596   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9597    return;
9598
9599   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9600                                 "move-cursor", 2,
9601                                 G_TYPE_ENUM, step,
9602                                 G_TYPE_INT, count);
9603
9604   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9605                                 "move-cursor", 2,
9606                                 G_TYPE_ENUM, step,
9607                                 G_TYPE_INT, count);
9608 }
9609
9610 static gint
9611 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9612                                  GtkTreeIter  *iter,
9613                                  GtkRBTree    *tree,
9614                                  GtkRBNode    *node)
9615 {
9616   gint retval = FALSE;
9617   do
9618     {
9619       g_return_val_if_fail (node != NULL, FALSE);
9620
9621       if (node->children)
9622         {
9623           GtkTreeIter child;
9624           GtkRBTree *new_tree;
9625           GtkRBNode *new_node;
9626
9627           new_tree = node->children;
9628           new_node = _gtk_rbtree_first (new_tree);
9629
9630           if (!gtk_tree_model_iter_children (model, &child, iter))
9631             return FALSE;
9632
9633           retval = gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node) | retval;
9634         }
9635
9636       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9637         retval = TRUE;
9638       gtk_tree_model_unref_node (model, iter);
9639       node = _gtk_rbtree_next (tree, node);
9640     }
9641   while (gtk_tree_model_iter_next (model, iter));
9642
9643   return retval;
9644 }
9645
9646 static gint
9647 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9648                                               GtkRBTree   *tree)
9649 {
9650   GtkTreeIter iter;
9651   GtkTreePath *path;
9652   GtkRBNode *node;
9653   gint retval;
9654
9655   if (!tree)
9656     return FALSE;
9657
9658   node = _gtk_rbtree_first (tree);
9659
9660   g_return_val_if_fail (node != NULL, FALSE);
9661   path = _gtk_tree_path_new_from_rbtree (tree, node);
9662   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9663                            &iter, path);
9664   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9665   gtk_tree_path_free (path);
9666
9667   return retval;
9668 }
9669
9670 static void
9671 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9672                                     GtkTreeViewColumn *column)
9673 {
9674   GtkTreeViewColumn *left_column;
9675   GtkTreeViewColumn *cur_column = NULL;
9676   GtkTreeViewColumnReorder *reorder;
9677   gboolean rtl;
9678   GList *tmp_list;
9679   gint left;
9680
9681   /* We want to precalculate the motion list such that we know what column slots
9682    * are available.
9683    */
9684   left_column = NULL;
9685   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9686
9687   /* First, identify all possible drop spots */
9688   if (rtl)
9689     tmp_list = g_list_last (tree_view->priv->columns);
9690   else
9691     tmp_list = g_list_first (tree_view->priv->columns);
9692
9693   while (tmp_list)
9694     {
9695       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9696       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9697
9698       if (gtk_tree_view_column_get_visible (cur_column) == FALSE)
9699         continue;
9700
9701       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9702       if (left_column != column && cur_column != column &&
9703           tree_view->priv->column_drop_func &&
9704           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9705         {
9706           left_column = cur_column;
9707           continue;
9708         }
9709       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9710       reorder->left_column = left_column;
9711       left_column = reorder->right_column = cur_column;
9712
9713       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9714     }
9715
9716   /* Add the last one */
9717   if (tree_view->priv->column_drop_func == NULL ||
9718       ((left_column != column) &&
9719        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9720     {
9721       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9722       reorder->left_column = left_column;
9723       reorder->right_column = NULL;
9724       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9725     }
9726
9727   /* We quickly check to see if it even makes sense to reorder columns. */
9728   /* If there is nothing that can be moved, then we return */
9729
9730   if (tree_view->priv->column_drag_info == NULL)
9731     return;
9732
9733   /* We know there are always 2 slots possbile, as you can always return column. */
9734   /* If that's all there is, return */
9735   if (tree_view->priv->column_drag_info->next == NULL ||
9736       (tree_view->priv->column_drag_info->next->next == NULL &&
9737        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9738        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9739     {
9740       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9741         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9742       g_list_free (tree_view->priv->column_drag_info);
9743       tree_view->priv->column_drag_info = NULL;
9744       return;
9745     }
9746   /* We fill in the ranges for the columns, now that we've isolated them */
9747   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9748
9749   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9750     {
9751       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9752
9753       reorder->left_align = left;
9754       if (tmp_list->next != NULL)
9755         {
9756           GtkAllocation right_allocation, left_allocation;
9757           GtkWidget    *left_button, *right_button;
9758
9759           g_assert (tmp_list->next->data);
9760
9761           right_button = gtk_tree_view_column_get_button (reorder->right_column);
9762           left_button  = gtk_tree_view_column_get_button
9763             (((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column);
9764
9765           gtk_widget_get_allocation (right_button, &right_allocation);
9766           gtk_widget_get_allocation (left_button, &left_allocation);
9767           left = reorder->right_align = (right_allocation.x + right_allocation.width + left_allocation.x) / 2;
9768         }
9769       else
9770         {
9771           reorder->right_align = gdk_window_get_width (tree_view->priv->header_window)
9772                                  + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9773         }
9774     }
9775 }
9776
9777 void
9778 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9779                                   GtkTreeViewColumn *column,
9780                                   GdkDevice         *device)
9781 {
9782   GdkEvent *send_event;
9783   GtkAllocation allocation;
9784   GtkAllocation button_allocation;
9785   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9786   GtkWidget *button;
9787   GdkDevice *pointer, *keyboard;
9788   GdkWindowAttr attributes;
9789   guint attributes_mask;
9790   GtkStyleContext *context;
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   context = gtk_widget_get_style_context (button);
9804   gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND);
9805
9806   gtk_widget_get_allocation (button, &button_allocation);
9807
9808   attributes.window_type = GDK_WINDOW_CHILD;
9809   attributes.wclass = GDK_INPUT_OUTPUT;
9810   attributes.x = button_allocation.x;
9811   attributes.y = 0;
9812   attributes.width = button_allocation.width;
9813   attributes.height = button_allocation.height;
9814   attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9815   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9816   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
9817
9818   tree_view->priv->drag_window = gdk_window_new (tree_view->priv->header_window,
9819                                                  &attributes,
9820                                                  attributes_mask);
9821   gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_window);
9822
9823   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
9824     {
9825       keyboard = device;
9826       pointer = gdk_device_get_associated_device (device);
9827     }
9828   else
9829     {
9830       pointer = device;
9831       keyboard = gdk_device_get_associated_device (device);
9832     }
9833
9834   gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
9835   gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);
9836
9837   gtk_grab_remove (button);
9838
9839   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9840   send_event->crossing.send_event = TRUE;
9841   send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (button)));
9842   send_event->crossing.subwindow = NULL;
9843   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9844   send_event->crossing.time = GDK_CURRENT_TIME;
9845   gdk_event_set_device (send_event, device);
9846
9847   gtk_propagate_event (button, send_event);
9848   gdk_event_free (send_event);
9849
9850   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9851   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9852   send_event->button.send_event = TRUE;
9853   send_event->button.time = GDK_CURRENT_TIME;
9854   send_event->button.x = -1;
9855   send_event->button.y = -1;
9856   send_event->button.axes = NULL;
9857   send_event->button.state = 0;
9858   send_event->button.button = GDK_BUTTON_PRIMARY;
9859   send_event->button.x_root = 0;
9860   send_event->button.y_root = 0;
9861   gdk_event_set_device (send_event, device);
9862
9863   gtk_propagate_event (button, send_event);
9864   gdk_event_free (send_event);
9865
9866   /* Kids, don't try this at home */
9867   g_object_ref (button);
9868   gtk_container_remove (GTK_CONTAINER (tree_view), button);
9869   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9870   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
9871   g_object_unref (button);
9872
9873   gtk_widget_get_allocation (button, &button_allocation);
9874   tree_view->priv->drag_column_x = button_allocation.x;
9875   allocation = button_allocation;
9876   allocation.x = 0;
9877   gtk_widget_size_allocate (button, &allocation);
9878   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9879
9880   tree_view->priv->drag_column = column;
9881   gdk_window_show (tree_view->priv->drag_window);
9882
9883   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9884   while (gtk_events_pending ())
9885     gtk_main_iteration ();
9886
9887   tree_view->priv->in_column_drag = TRUE;
9888
9889   gdk_device_grab (pointer,
9890                    tree_view->priv->drag_window,
9891                    GDK_OWNERSHIP_NONE,
9892                    FALSE,
9893                    GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9894                    NULL,
9895                    GDK_CURRENT_TIME);
9896   gdk_device_grab (keyboard,
9897                    tree_view->priv->drag_window,
9898                    GDK_OWNERSHIP_NONE,
9899                    FALSE,
9900                    GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
9901                    NULL,
9902                    GDK_CURRENT_TIME);
9903 }
9904
9905 static void
9906 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9907                                 GtkRBTree          *tree,
9908                                 GtkRBNode          *node)
9909 {
9910   GtkAllocation allocation;
9911   GdkRectangle rect;
9912
9913   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9914     return;
9915
9916   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9917   rect.x = 0;
9918   rect.width = gtk_tree_view_get_expander_size (tree_view);
9919   rect.width = MAX (rect.width, MAX (tree_view->priv->width, allocation.width));
9920
9921   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9922   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9923
9924   gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9925 }
9926
9927 void
9928 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9929                                 GtkRBTree          *tree,
9930                                 GtkRBNode          *node,
9931                                 const GdkRectangle *clip_rect)
9932 {
9933   GtkAllocation allocation;
9934   GdkRectangle rect;
9935
9936   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9937     return;
9938
9939   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9940   rect.x = 0;
9941   rect.width = MAX (tree_view->priv->width, allocation.width);
9942
9943   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9944   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9945
9946   if (clip_rect)
9947     {
9948       GdkRectangle new_rect;
9949
9950       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9951
9952       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9953     }
9954   else
9955     {
9956       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9957     }
9958 }
9959
9960 static inline gint
9961 gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view)
9962 {
9963   if (tree_view->priv->headers_visible)
9964     return tree_view->priv->header_height;
9965   /* else */
9966   return 0;
9967 }
9968
9969 gint
9970 _gtk_tree_view_get_header_height (GtkTreeView *tree_view)
9971 {
9972   return tree_view->priv->header_height;
9973 }
9974
9975 void
9976 _gtk_tree_view_get_row_separator_func (GtkTreeView                 *tree_view,
9977                                        GtkTreeViewRowSeparatorFunc *func,
9978                                        gpointer                    *data)
9979 {
9980   *func = tree_view->priv->row_separator_func;
9981   *data = tree_view->priv->row_separator_data;
9982 }
9983
9984 GtkTreePath *
9985 _gtk_tree_view_get_anchor_path (GtkTreeView *tree_view)
9986 {
9987   if (tree_view->priv->anchor)
9988     return gtk_tree_row_reference_get_path (tree_view->priv->anchor);
9989
9990   return NULL;
9991 }
9992
9993 void
9994 _gtk_tree_view_set_anchor_path (GtkTreeView *tree_view,
9995                                 GtkTreePath *anchor_path)
9996 {
9997   if (tree_view->priv->anchor)
9998     {
9999       gtk_tree_row_reference_free (tree_view->priv->anchor);
10000       tree_view->priv->anchor = NULL;
10001     }
10002
10003   if (anchor_path && tree_view->priv->model)
10004     tree_view->priv->anchor =
10005       gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
10006                                         tree_view->priv->model, anchor_path);
10007 }
10008
10009 GtkRBTree *
10010 _gtk_tree_view_get_rbtree (GtkTreeView *tree_view)
10011 {
10012   return tree_view->priv->tree;
10013 }
10014
10015 gboolean
10016 _gtk_tree_view_get_cursor_node (GtkTreeView  *tree_view,
10017                                 GtkRBTree   **tree,
10018                                 GtkRBNode   **node)
10019 {
10020   GtkTreeViewPrivate *priv;
10021
10022   priv = tree_view->priv;
10023
10024   if (priv->cursor_node == NULL)
10025     return FALSE;
10026
10027   *tree = priv->cursor_tree;
10028   *node = priv->cursor_node;
10029
10030   return TRUE;
10031 }
10032
10033 GdkWindow *
10034 _gtk_tree_view_get_header_window (GtkTreeView *tree_view)
10035 {
10036   return tree_view->priv->header_window;
10037 }
10038
10039 GtkTreeViewColumn *
10040 _gtk_tree_view_get_focus_column (GtkTreeView *tree_view)
10041 {
10042   return tree_view->priv->focus_column;
10043 }
10044
10045 void
10046 _gtk_tree_view_set_focus_column (GtkTreeView       *tree_view,
10047                                  GtkTreeViewColumn *column)
10048 {
10049   GtkTreeViewColumn *old_column = tree_view->priv->focus_column;
10050
10051   if (old_column == column)
10052     return;
10053
10054   tree_view->priv->focus_column = column;
10055
10056   _gtk_tree_view_accessible_update_focus_column (tree_view,
10057                                                  old_column,
10058                                                  column);
10059 }
10060
10061
10062 static void
10063 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
10064                                GtkTreePath        *path,
10065                                const GdkRectangle *clip_rect)
10066 {
10067   GtkRBTree *tree = NULL;
10068   GtkRBNode *node = NULL;
10069
10070   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
10071
10072   if (tree)
10073     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
10074 }
10075
10076 /* x and y are the mouse position
10077  */
10078 static void
10079 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
10080                           cairo_t     *cr,
10081                           GtkRBTree   *tree,
10082                           GtkRBNode   *node)
10083 {
10084   GdkRectangle area;
10085   GtkStateFlags state = 0;
10086   GtkStyleContext *context;
10087   GtkWidget *widget;
10088   gint x_offset = 0;
10089   gint x2;
10090   gint vertical_separator;
10091   GtkCellRendererState flags = 0;
10092
10093   widget = GTK_WIDGET (tree_view);
10094   context = gtk_widget_get_style_context (widget);
10095
10096   gtk_widget_style_get (widget,
10097                         "vertical-separator", &vertical_separator,
10098                         NULL);
10099
10100   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
10101     return;
10102
10103   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
10104
10105   area.x = x_offset;
10106   area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
10107                                                  vertical_separator);
10108   area.width = x2 - x_offset;
10109   area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
10110                                                     vertical_separator);
10111
10112   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
10113     flags |= GTK_CELL_RENDERER_SELECTED;
10114
10115   if (node == tree_view->priv->prelight_node &&
10116       tree_view->priv->arrow_prelit)
10117     flags |= GTK_CELL_RENDERER_PRELIT;
10118
10119   state = gtk_cell_renderer_get_state (NULL, widget, flags);
10120
10121   if (node->children != NULL)
10122     state |= GTK_STATE_FLAG_ACTIVE;
10123   else
10124     state &= ~(GTK_STATE_FLAG_ACTIVE);
10125
10126   gtk_style_context_save (context);
10127
10128   gtk_style_context_set_state (context, state);
10129   gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
10130
10131   gtk_render_expander (context, cr,
10132                        area.x, area.y,
10133                        area.width, area.height);
10134
10135   gtk_style_context_restore (context);
10136 }
10137
10138 static void
10139 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
10140
10141 {
10142   GtkTreePath *cursor_path;
10143
10144   if ((tree_view->priv->tree == NULL) ||
10145       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
10146     return;
10147
10148   cursor_path = NULL;
10149   if (tree_view->priv->cursor_node)
10150     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10151                                                   tree_view->priv->cursor_node);
10152
10153   if (cursor_path == NULL)
10154     {
10155       /* Consult the selection before defaulting to the
10156        * first focusable element
10157        */
10158       GList *selected_rows;
10159       GtkTreeModel *model;
10160       GtkTreeSelection *selection;
10161
10162       selection = gtk_tree_view_get_selection (tree_view);
10163       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
10164
10165       if (selected_rows)
10166         {
10167           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
10168           g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free);
10169         }
10170       else
10171         {
10172           cursor_path = gtk_tree_path_new_first ();
10173           search_first_focusable_path (tree_view, &cursor_path,
10174                                        TRUE, NULL, NULL);
10175         }
10176
10177       if (cursor_path)
10178         {
10179           if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
10180             gtk_tree_view_real_set_cursor (tree_view, cursor_path, 0);
10181           else
10182             gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10183         }
10184     }
10185
10186   if (cursor_path)
10187     {
10188       tree_view->priv->draw_keyfocus = TRUE;
10189
10190       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10191       gtk_tree_path_free (cursor_path);
10192
10193       if (tree_view->priv->focus_column == NULL)
10194         {
10195           GList *list;
10196           for (list = tree_view->priv->columns; list; list = list->next)
10197             {
10198               if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
10199                 {
10200                   GtkCellArea *cell_area;
10201
10202                   _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
10203
10204                   /* This happens when the treeview initially grabs focus and there
10205                    * is no column in focus, here we explicitly focus into the first cell */
10206                   cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10207                   if (!gtk_cell_area_get_focus_cell (cell_area))
10208                     {
10209                       gboolean rtl;
10210
10211                       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10212                       gtk_cell_area_focus (cell_area,
10213                                            rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
10214                     }
10215
10216                   break;
10217                 }
10218             }
10219         }
10220     }
10221 }
10222
10223 static void
10224 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
10225                                    gint         count)
10226 {
10227   gint selection_count;
10228   GtkRBTree *new_cursor_tree = NULL;
10229   GtkRBNode *new_cursor_node = NULL;
10230   GtkTreePath *cursor_path = NULL;
10231   gboolean grab_focus = TRUE;
10232   gboolean selectable;
10233   GtkDirectionType direction;
10234   GtkCellArea *cell_area = NULL;
10235   GtkCellRenderer *last_focus_cell = NULL;
10236   GtkTreeIter iter;
10237
10238   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10239     return;
10240
10241   if (tree_view->priv->cursor_node == NULL)
10242     return;
10243
10244   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10245                                                 tree_view->priv->cursor_node);
10246
10247   direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
10248
10249   if (tree_view->priv->focus_column)
10250     cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10251
10252   /* If focus stays in the area for this row, then just return for this round */
10253   if (cell_area && (count == -1 || count == 1) &&
10254       gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path))
10255     {
10256       gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
10257                                                tree_view->priv->model,
10258                                                &iter,
10259                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10260                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10261
10262       /* Save the last cell that had focus, if we hit the end of the view we'll give
10263        * focus back to it. */
10264       last_focus_cell = gtk_cell_area_get_focus_cell (cell_area);
10265
10266       /* If focus stays in the area, no need to change the cursor row */
10267       if (gtk_cell_area_focus (cell_area, direction))
10268         return;
10269     }
10270
10271   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
10272   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
10273                                                       tree_view->priv->cursor_node,
10274                                                       cursor_path);
10275
10276   if (selection_count == 0
10277       && gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE
10278       && !tree_view->priv->modify_selection_pressed
10279       && selectable)
10280     {
10281       /* Don't move the cursor, but just select the current node */
10282       new_cursor_tree = tree_view->priv->cursor_tree;
10283       new_cursor_node = tree_view->priv->cursor_node;
10284     }
10285   else
10286     {
10287       if (count == -1)
10288         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10289                                &new_cursor_tree, &new_cursor_node);
10290       else
10291         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10292                                &new_cursor_tree, &new_cursor_node);
10293     }
10294
10295   gtk_tree_path_free (cursor_path);
10296
10297   if (new_cursor_node)
10298     {
10299       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10300
10301       search_first_focusable_path (tree_view, &cursor_path,
10302                                    (count != -1),
10303                                    &new_cursor_tree,
10304                                    &new_cursor_node);
10305
10306       if (cursor_path)
10307         gtk_tree_path_free (cursor_path);
10308     }
10309
10310   /*
10311    * If the list has only one item and multi-selection is set then select
10312    * the row (if not yet selected).
10313    */
10314   if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE &&
10315       new_cursor_node == NULL)
10316     {
10317       if (count == -1)
10318         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10319                                &new_cursor_tree, &new_cursor_node);
10320       else
10321         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10322                                &new_cursor_tree, &new_cursor_node);
10323
10324       if (new_cursor_node == NULL
10325           && !GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
10326         {
10327           new_cursor_node = tree_view->priv->cursor_node;
10328           new_cursor_tree = tree_view->priv->cursor_tree;
10329         }
10330       else
10331         {
10332           new_cursor_tree = NULL;
10333           new_cursor_node = NULL;
10334         }
10335     }
10336
10337   if (new_cursor_node)
10338     {
10339       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10340       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10341       gtk_tree_path_free (cursor_path);
10342
10343       /* Give focus to the area in the new row */
10344       if (cell_area)
10345         gtk_cell_area_focus (cell_area, direction);
10346     }
10347   else
10348     {
10349       gtk_tree_view_clamp_node_visible (tree_view,
10350                                         tree_view->priv->cursor_tree,
10351                                         tree_view->priv->cursor_node);
10352
10353       if (!tree_view->priv->extend_selection_pressed)
10354         {
10355           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
10356                                           count < 0 ?
10357                                           GTK_DIR_UP : GTK_DIR_DOWN))
10358             {
10359               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10360
10361               if (toplevel)
10362                 gtk_widget_child_focus (toplevel,
10363                                         count < 0 ?
10364                                         GTK_DIR_TAB_BACKWARD :
10365                                         GTK_DIR_TAB_FORWARD);
10366
10367               grab_focus = FALSE;
10368             }
10369         }
10370       else
10371         {
10372           gtk_widget_error_bell (GTK_WIDGET (tree_view));
10373         }
10374
10375       if (cell_area)
10376         gtk_cell_area_set_focus_cell (cell_area, last_focus_cell);
10377     }
10378
10379   if (grab_focus)
10380     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10381 }
10382
10383 static void
10384 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
10385                                         gint         count)
10386 {
10387   GtkTreePath *old_cursor_path = NULL;
10388   GtkTreePath *cursor_path = NULL;
10389   GtkRBTree *start_cursor_tree = NULL;
10390   GtkRBNode *start_cursor_node = NULL;
10391   GtkRBTree *cursor_tree;
10392   GtkRBNode *cursor_node;
10393   gint y;
10394   gint window_y;
10395   gint vertical_separator;
10396
10397   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10398     return;
10399
10400   if (tree_view->priv->cursor_node == NULL)
10401     return;
10402
10403   old_cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10404                                                     tree_view->priv->cursor_node);
10405
10406   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
10407
10408   y = _gtk_rbtree_node_find_offset (tree_view->priv->cursor_tree, tree_view->priv->cursor_node);
10409   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
10410   y += tree_view->priv->cursor_offset;
10411   y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
10412   y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment),  (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
10413
10414   if (y >= tree_view->priv->height)
10415     y = tree_view->priv->height - 1;
10416
10417   tree_view->priv->cursor_offset =
10418     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
10419                              &cursor_tree, &cursor_node);
10420
10421   if (cursor_tree == NULL)
10422     {
10423       /* FIXME: we lost the cursor.  Should we try to get one? */
10424       gtk_tree_path_free (old_cursor_path);
10425       return;
10426     }
10427
10428   if (tree_view->priv->cursor_offset
10429       > gtk_tree_view_get_row_height (tree_view, cursor_node))
10430     {
10431       _gtk_rbtree_next_full (cursor_tree, cursor_node,
10432                              &cursor_tree, &cursor_node);
10433       tree_view->priv->cursor_offset -= gtk_tree_view_get_row_height (tree_view, cursor_node);
10434     }
10435
10436   y -= tree_view->priv->cursor_offset;
10437   cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10438
10439   start_cursor_tree = cursor_tree;
10440   start_cursor_node = cursor_node;
10441
10442   if (! search_first_focusable_path (tree_view, &cursor_path,
10443                                      (count != -1),
10444                                      &cursor_tree, &cursor_node))
10445     {
10446       /* It looks like we reached the end of the view without finding
10447        * a focusable row.  We will step backwards to find the last
10448        * focusable row.
10449        */
10450       cursor_tree = start_cursor_tree;
10451       cursor_node = start_cursor_node;
10452       cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10453
10454       search_first_focusable_path (tree_view, &cursor_path,
10455                                    (count == -1),
10456                                    &cursor_tree, &cursor_node);
10457     }
10458
10459   if (!cursor_path)
10460     goto cleanup;
10461
10462   /* update y */
10463   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10464
10465   gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10466
10467   y -= window_y;
10468   gtk_tree_view_scroll_to_point (tree_view, -1, y);
10469   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10470   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10471
10472   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
10473     gtk_widget_error_bell (GTK_WIDGET (tree_view));
10474
10475   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10476
10477 cleanup:
10478   gtk_tree_path_free (old_cursor_path);
10479   gtk_tree_path_free (cursor_path);
10480 }
10481
10482 static void
10483 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
10484                                       gint         count)
10485 {
10486   GtkTreePath *cursor_path = NULL;
10487   GtkTreeViewColumn *column;
10488   GtkTreeIter iter;
10489   GList *list;
10490   gboolean found_column = FALSE;
10491   gboolean rtl;
10492   GtkDirectionType direction;
10493   GtkCellArea     *cell_area;
10494   GtkCellRenderer *last_focus_cell = NULL;
10495   GtkCellArea     *last_focus_area = NULL;
10496
10497   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10498
10499   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10500     return;
10501
10502   if (tree_view->priv->cursor_node == NULL)
10503     return;
10504
10505   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10506                                                 tree_view->priv->cursor_node);
10507
10508   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
10509     {
10510       gtk_tree_path_free (cursor_path);
10511       return;
10512     }
10513   gtk_tree_path_free (cursor_path);
10514
10515   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
10516   if (tree_view->priv->focus_column)
10517     {
10518       /* Save the cell/area we are moving focus from, if moving the cursor
10519        * by one step hits the end we'll set focus back here */
10520       last_focus_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10521       last_focus_cell = gtk_cell_area_get_focus_cell (last_focus_area);
10522
10523       for (; list; list = (rtl ? list->prev : list->next))
10524         {
10525           if (list->data == tree_view->priv->focus_column)
10526             break;
10527         }
10528     }
10529
10530   direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
10531
10532   while (list)
10533     {
10534       column = list->data;
10535       if (gtk_tree_view_column_get_visible (column) == FALSE)
10536         goto loop_end;
10537
10538       gtk_tree_view_column_cell_set_cell_data (column,
10539                                                tree_view->priv->model,
10540                                                &iter,
10541                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10542                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10543
10544       cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
10545       if (gtk_cell_area_focus (cell_area, direction))
10546         {
10547           _gtk_tree_view_set_focus_column (tree_view, column);
10548           found_column = TRUE;
10549           break;
10550         }
10551
10552     loop_end:
10553       if (count == 1)
10554         list = rtl ? list->prev : list->next;
10555       else
10556         list = rtl ? list->next : list->prev;
10557     }
10558
10559   if (found_column)
10560     {
10561       if (!gtk_tree_view_has_can_focus_cell (tree_view))
10562         _gtk_tree_view_queue_draw_node (tree_view,
10563                                         tree_view->priv->cursor_tree,
10564                                         tree_view->priv->cursor_node,
10565                                         NULL);
10566       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
10567       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10568     }
10569   else
10570     {
10571       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10572
10573       if (last_focus_area)
10574         gtk_cell_area_set_focus_cell (last_focus_area, last_focus_cell);
10575     }
10576
10577   gtk_tree_view_clamp_column_visible (tree_view,
10578                                       tree_view->priv->focus_column, TRUE);
10579 }
10580
10581 static void
10582 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
10583                                      gint         count)
10584 {
10585   GtkRBTree *cursor_tree;
10586   GtkRBNode *cursor_node;
10587   GtkTreePath *path;
10588   GtkTreePath *old_path;
10589
10590   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10591     return;
10592
10593   g_return_if_fail (tree_view->priv->tree != NULL);
10594
10595   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
10596
10597   cursor_tree = tree_view->priv->tree;
10598
10599   if (count == -1)
10600     {
10601       cursor_node = _gtk_rbtree_first (cursor_tree);
10602
10603       /* Now go forward to find the first focusable row. */
10604       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10605       search_first_focusable_path (tree_view, &path,
10606                                    TRUE, &cursor_tree, &cursor_node);
10607     }
10608   else
10609     {
10610       cursor_node = cursor_tree->root;
10611
10612       do
10613         {
10614           while (cursor_node && !_gtk_rbtree_is_nil (cursor_node->right))
10615             cursor_node = cursor_node->right;
10616           if (cursor_node->children == NULL)
10617             break;
10618
10619           cursor_tree = cursor_node->children;
10620           cursor_node = cursor_tree->root;
10621         }
10622       while (1);
10623
10624       /* Now go backwards to find last focusable row. */
10625       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10626       search_first_focusable_path (tree_view, &path,
10627                                    FALSE, &cursor_tree, &cursor_node);
10628     }
10629
10630   if (!path)
10631     goto cleanup;
10632
10633   if (gtk_tree_path_compare (old_path, path))
10634     {
10635       gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
10636       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10637     }
10638   else
10639     {
10640       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10641     }
10642
10643 cleanup:
10644   gtk_tree_path_free (old_path);
10645   gtk_tree_path_free (path);
10646 }
10647
10648 static gboolean
10649 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10650 {
10651   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10652     return FALSE;
10653
10654   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10655     return FALSE;
10656
10657   gtk_tree_selection_select_all (tree_view->priv->selection);
10658
10659   return TRUE;
10660 }
10661
10662 static gboolean
10663 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
10664 {
10665   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10666     return FALSE;
10667
10668   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10669     return FALSE;
10670
10671   gtk_tree_selection_unselect_all (tree_view->priv->selection);
10672
10673   return TRUE;
10674 }
10675
10676 static gboolean
10677 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10678                                       gboolean     start_editing)
10679 {
10680   GtkRBTree *new_tree = NULL;
10681   GtkRBNode *new_node = NULL;
10682   GtkRBTree *cursor_tree = NULL;
10683   GtkRBNode *cursor_node = NULL;
10684   GtkTreePath *cursor_path = NULL;
10685   GtkTreeSelectMode mode = 0;
10686
10687   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10688     return FALSE;
10689
10690   if (tree_view->priv->cursor_node == NULL)
10691     return FALSE;
10692
10693   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10694                                                 tree_view->priv->cursor_node);
10695
10696   _gtk_tree_view_find_node (tree_view, cursor_path,
10697                             &cursor_tree, &cursor_node);
10698
10699   if (cursor_tree == NULL)
10700     {
10701       gtk_tree_path_free (cursor_path);
10702       return FALSE;
10703     }
10704
10705   if (!tree_view->priv->extend_selection_pressed && start_editing &&
10706       tree_view->priv->focus_column)
10707     {
10708       if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE))
10709         {
10710           gtk_tree_path_free (cursor_path);
10711           return TRUE;
10712         }
10713     }
10714
10715   if (tree_view->priv->modify_selection_pressed)
10716     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10717   if (tree_view->priv->extend_selection_pressed)
10718     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10719
10720   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10721                                             cursor_node,
10722                                             cursor_tree,
10723                                             cursor_path,
10724                                             mode,
10725                                             FALSE);
10726
10727   /* We bail out if the original (tree, node) don't exist anymore after
10728    * handling the selection-changed callback.  We do return TRUE because
10729    * the key press has been handled at this point.
10730    */
10731   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10732
10733   if (cursor_tree != new_tree || cursor_node != new_node)
10734     return FALSE;
10735
10736   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10737
10738   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10739   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10740
10741   if (!tree_view->priv->extend_selection_pressed)
10742     gtk_tree_view_row_activated (tree_view, cursor_path,
10743                                  tree_view->priv->focus_column);
10744
10745   gtk_tree_path_free (cursor_path);
10746
10747   return TRUE;
10748 }
10749
10750 static gboolean
10751 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10752 {
10753   GtkRBTree *new_tree = NULL;
10754   GtkRBNode *new_node = NULL;
10755   GtkTreePath *cursor_path = NULL;
10756
10757   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10758     return FALSE;
10759
10760   if (tree_view->priv->cursor_node == NULL)
10761     return FALSE;
10762
10763   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10764                                                 tree_view->priv->cursor_node);
10765
10766   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10767                                             tree_view->priv->cursor_node,
10768                                             tree_view->priv->cursor_tree,
10769                                             cursor_path,
10770                                             GTK_TREE_SELECT_MODE_TOGGLE,
10771                                             FALSE);
10772
10773   /* We bail out if the original (tree, node) don't exist anymore after
10774    * handling the selection-changed callback.  We do return TRUE because
10775    * the key press has been handled at this point.
10776    */
10777   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10778
10779   if (tree_view->priv->cursor_node != new_node)
10780     return FALSE;
10781
10782   gtk_tree_view_clamp_node_visible (tree_view,
10783                                     tree_view->priv->cursor_tree,
10784                                     tree_view->priv->cursor_node);
10785
10786   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10787   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10788   gtk_tree_path_free (cursor_path);
10789
10790   return TRUE;
10791 }
10792
10793 static gboolean
10794 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10795                                                gboolean     logical,
10796                                                gboolean     expand,
10797                                                gboolean     open_all)
10798 {
10799   GtkTreePath *cursor_path = NULL;
10800
10801   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10802     return FALSE;
10803
10804   if (tree_view->priv->cursor_node == NULL)
10805     return FALSE;
10806
10807   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10808                                                 tree_view->priv->cursor_node);
10809
10810   /* Don't handle the event if we aren't an expander */
10811   if (!GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT))
10812     return FALSE;
10813
10814   if (!logical
10815       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10816     expand = !expand;
10817
10818   if (expand)
10819     gtk_tree_view_real_expand_row (tree_view,
10820                                    cursor_path,
10821                                    tree_view->priv->cursor_tree,
10822                                    tree_view->priv->cursor_node,
10823                                    open_all,
10824                                    TRUE);
10825   else
10826     gtk_tree_view_real_collapse_row (tree_view,
10827                                      cursor_path,
10828                                      tree_view->priv->cursor_tree,
10829                                      tree_view->priv->cursor_node,
10830                                      TRUE);
10831
10832   gtk_tree_path_free (cursor_path);
10833
10834   return TRUE;
10835 }
10836
10837 static gboolean
10838 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10839 {
10840   GtkTreePath *cursor_path = NULL;
10841   GdkModifierType state;
10842
10843   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10844     goto out;
10845
10846   if (tree_view->priv->cursor_node == NULL)
10847     goto out;
10848
10849   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10850                                                 tree_view->priv->cursor_node);
10851
10852   if (tree_view->priv->cursor_tree->parent_node)
10853     {
10854       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10855
10856       gtk_tree_path_up (cursor_path);
10857
10858       if (gtk_get_current_event_state (&state))
10859         {
10860           GdkModifierType modify_mod_mask;
10861
10862           modify_mod_mask =
10863             gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
10864                                           GDK_MODIFIER_INTENT_MODIFY_SELECTION);
10865
10866           if ((state & modify_mod_mask) == modify_mod_mask)
10867             tree_view->priv->modify_selection_pressed = TRUE;
10868         }
10869
10870       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10871       gtk_tree_path_free (cursor_path);
10872
10873       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10874
10875       tree_view->priv->modify_selection_pressed = FALSE;
10876
10877       return TRUE;
10878     }
10879
10880  out:
10881
10882   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10883   return FALSE;
10884 }
10885
10886 static gboolean
10887 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10888 {
10889   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
10890   tree_view->priv->typeselect_flush_timeout = 0;
10891
10892   return FALSE;
10893 }
10894
10895 /* Cut and paste from gtkwindow.c */
10896 static void
10897 send_focus_change (GtkWidget *widget,
10898                    GdkDevice *device,
10899                    gboolean   in)
10900 {
10901   GdkDeviceManager *device_manager;
10902   GList *devices, *d;
10903
10904   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
10905   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
10906   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
10907   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
10908
10909   for (d = devices; d; d = d->next)
10910     {
10911       GdkDevice *dev = d->data;
10912       GdkEvent *fevent;
10913       GdkWindow *window;
10914
10915       if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
10916         continue;
10917
10918       window = gtk_widget_get_window (widget);
10919
10920       /* Skip non-master keyboards that haven't
10921        * selected for events from this window
10922        */
10923       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
10924           !gdk_window_get_device_events (window, dev))
10925         continue;
10926
10927       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10928
10929       fevent->focus_change.type = GDK_FOCUS_CHANGE;
10930       fevent->focus_change.window = g_object_ref (window);
10931       fevent->focus_change.in = in;
10932       gdk_event_set_device (fevent, device);
10933
10934       gtk_widget_send_focus_change (widget, fevent);
10935
10936       gdk_event_free (fevent);
10937     }
10938
10939   g_list_free (devices);
10940 }
10941
10942 static void
10943 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10944 {
10945   GtkWidget *frame, *vbox, *toplevel;
10946   GdkScreen *screen;
10947
10948   if (tree_view->priv->search_custom_entry_set)
10949     return;
10950
10951   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10952   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10953
10954    if (tree_view->priv->search_window != NULL)
10955      {
10956        if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10957          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10958                                       GTK_WINDOW (tree_view->priv->search_window));
10959        else if (gtk_window_has_group (GTK_WINDOW (tree_view->priv->search_window)))
10960          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
10961                                          GTK_WINDOW (tree_view->priv->search_window));
10962
10963        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10964
10965        return;
10966      }
10967
10968   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10969   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10970
10971   if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10972     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10973                                  GTK_WINDOW (tree_view->priv->search_window));
10974
10975   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10976                             GDK_WINDOW_TYPE_HINT_UTILITY);
10977   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10978   g_signal_connect (tree_view->priv->search_window, "delete-event",
10979                     G_CALLBACK (gtk_tree_view_search_delete_event),
10980                     tree_view);
10981   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10982                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10983                     tree_view);
10984   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10985                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10986                     tree_view);
10987   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10988                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10989                     tree_view);
10990
10991   frame = gtk_frame_new (NULL);
10992   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10993   gtk_widget_show (frame);
10994   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10995
10996   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10997   gtk_widget_show (vbox);
10998   gtk_container_add (GTK_CONTAINER (frame), vbox);
10999   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
11000
11001   /* add entry */
11002   tree_view->priv->search_entry = gtk_entry_new ();
11003   gtk_widget_show (tree_view->priv->search_entry);
11004   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
11005                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
11006                     tree_view);
11007   g_signal_connect (tree_view->priv->search_entry,
11008                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
11009                     tree_view);
11010
11011   g_signal_connect (_gtk_entry_get_im_context (GTK_ENTRY (tree_view->priv->search_entry)),
11012                     "preedit-changed",
11013                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
11014                     tree_view);
11015
11016   gtk_container_add (GTK_CONTAINER (vbox),
11017                      tree_view->priv->search_entry);
11018
11019   gtk_widget_realize (tree_view->priv->search_entry);
11020 }
11021
11022 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
11023  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
11024  */
11025 static gboolean
11026 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
11027                                              GdkDevice   *device,
11028                                              gboolean     keybinding)
11029 {
11030   /* We only start interactive search if we have focus or the columns
11031    * have focus.  If one of our children have focus, we don't want to
11032    * start the search.
11033    */
11034   GList *list;
11035   gboolean found_focus = FALSE;
11036   GtkWidgetClass *entry_parent_class;
11037
11038   if (!tree_view->priv->enable_search && !keybinding)
11039     return FALSE;
11040
11041   if (tree_view->priv->search_custom_entry_set)
11042     return FALSE;
11043
11044   if (tree_view->priv->search_window != NULL &&
11045       gtk_widget_get_visible (tree_view->priv->search_window))
11046     return TRUE;
11047
11048   for (list = tree_view->priv->columns; list; list = list->next)
11049     {
11050       GtkTreeViewColumn *column;
11051       GtkWidget         *button;
11052
11053       column = list->data;
11054       if (!gtk_tree_view_column_get_visible (column))
11055         continue;
11056
11057       button = gtk_tree_view_column_get_button (column);
11058       if (gtk_widget_has_focus (button))
11059         {
11060           found_focus = TRUE;
11061           break;
11062         }
11063     }
11064
11065   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
11066     found_focus = TRUE;
11067
11068   if (!found_focus)
11069     return FALSE;
11070
11071   if (tree_view->priv->search_column < 0)
11072     return FALSE;
11073
11074   gtk_tree_view_ensure_interactive_directory (tree_view);
11075
11076   if (keybinding)
11077     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
11078
11079   /* done, show it */
11080   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
11081   gtk_widget_show (tree_view->priv->search_window);
11082   if (tree_view->priv->search_entry_changed_id == 0)
11083     {
11084       tree_view->priv->search_entry_changed_id =
11085         g_signal_connect (tree_view->priv->search_entry, "changed",
11086                           G_CALLBACK (gtk_tree_view_search_init),
11087                           tree_view);
11088     }
11089
11090   tree_view->priv->typeselect_flush_timeout =
11091     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
11092                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
11093                    tree_view);
11094
11095   /* Grab focus will select all the text.  We don't want that to happen, so we
11096    * call the parent instance and bypass the selection change.  This is probably
11097    * really non-kosher. */
11098   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
11099   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
11100
11101   /* send focus-in event */
11102   send_focus_change (tree_view->priv->search_entry, device, TRUE);
11103
11104   /* search first matching iter */
11105   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
11106
11107   return TRUE;
11108 }
11109
11110 static gboolean
11111 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
11112 {
11113   return gtk_tree_view_real_start_interactive_search (tree_view,
11114                                                       gtk_get_current_event_device (),
11115                                                       TRUE);
11116 }
11117
11118 /* FIXME this adjust_allocation is a big cut-and-paste from
11119  * GtkCList, needs to be some "official" way to do this
11120  * factored out.
11121  */
11122 typedef struct
11123 {
11124   GdkWindow *window;
11125   int dx;
11126   int dy;
11127 } ScrollData;
11128
11129 /* The window to which widget->window is relative */
11130 #define ALLOCATION_WINDOW(widget)               \
11131    (!gtk_widget_get_has_window (widget) ?                   \
11132     gtk_widget_get_window (widget) :                        \
11133     gdk_window_get_parent (gtk_widget_get_window (widget)))
11134
11135 static void
11136 adjust_allocation_recurse (GtkWidget *widget,
11137                            gpointer   data)
11138 {
11139   GtkAllocation allocation;
11140   ScrollData *scroll_data = data;
11141
11142   /* Need to really size allocate instead of just poking
11143    * into widget->allocation if the widget is not realized.
11144    * FIXME someone figure out why this was.
11145    */
11146   gtk_widget_get_allocation (widget, &allocation);
11147   if (!gtk_widget_get_realized (widget))
11148     {
11149       if (gtk_widget_get_visible (widget))
11150         {
11151           GdkRectangle tmp_rectangle = allocation;
11152           tmp_rectangle.x += scroll_data->dx;
11153           tmp_rectangle.y += scroll_data->dy;
11154
11155           gtk_widget_size_allocate (widget, &tmp_rectangle);
11156         }
11157     }
11158   else
11159     {
11160       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
11161         {
11162           allocation.x += scroll_data->dx;
11163           allocation.y += scroll_data->dy;
11164           gtk_widget_set_allocation (widget, &allocation);
11165
11166           if (GTK_IS_CONTAINER (widget))
11167             gtk_container_forall (GTK_CONTAINER (widget),
11168                                   adjust_allocation_recurse,
11169                                   data);
11170         }
11171     }
11172 }
11173
11174 static void
11175 adjust_allocation (GtkWidget *widget,
11176                    int        dx,
11177                    int        dy)
11178 {
11179   ScrollData scroll_data;
11180
11181   if (gtk_widget_get_realized (widget))
11182     scroll_data.window = ALLOCATION_WINDOW (widget);
11183   else
11184     scroll_data.window = NULL;
11185
11186   scroll_data.dx = dx;
11187   scroll_data.dy = dy;
11188
11189   adjust_allocation_recurse (widget, &scroll_data);
11190 }
11191
11192 /* Callbacks */
11193 static void
11194 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
11195                                   GtkTreeView   *tree_view)
11196 {
11197   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11198     {
11199       gint dy;
11200
11201       gdk_window_move (tree_view->priv->bin_window,
11202                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11203                        gtk_tree_view_get_effective_header_height (tree_view));
11204       gdk_window_move (tree_view->priv->header_window,
11205                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11206                        0);
11207       dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11208       if (dy)
11209         {
11210           update_prelight (tree_view,
11211                            tree_view->priv->event_last_x,
11212                            tree_view->priv->event_last_y - dy);
11213
11214           if (tree_view->priv->edited_column)
11215             {
11216               GList *list;
11217               GtkTreeViewChild *child = NULL;
11218               GtkCellEditable *edit_widget;
11219               GtkCellArea *area;
11220
11221               area        = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column));
11222               edit_widget = gtk_cell_area_get_edit_widget (area);
11223               if (GTK_IS_WIDGET (edit_widget))
11224                 {
11225                   adjust_allocation (GTK_WIDGET (edit_widget), 0, dy);
11226
11227                   for (list = tree_view->priv->children; list; list = list->next)
11228                     {
11229                       child = (GtkTreeViewChild *)list->data;
11230                       if (child->widget == GTK_WIDGET (edit_widget))
11231                         {
11232                           child->y += dy;
11233                           break;
11234                         }
11235                     }
11236                 }
11237             }
11238         }
11239       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
11240
11241       if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
11242         {
11243           /* update our dy and top_row */
11244           tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11245
11246           if (!tree_view->priv->in_top_row_to_dy)
11247             gtk_tree_view_dy_to_top_row (tree_view);
11248         }
11249     }
11250 }
11251
11252 \f
11253
11254 /* Public methods
11255  */
11256
11257 /**
11258  * gtk_tree_view_new:
11259  *
11260  * Creates a new #GtkTreeView widget.
11261  *
11262  * Return value: A newly created #GtkTreeView widget.
11263  **/
11264 GtkWidget *
11265 gtk_tree_view_new (void)
11266 {
11267   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
11268 }
11269
11270 /**
11271  * gtk_tree_view_new_with_model:
11272  * @model: the model.
11273  *
11274  * Creates a new #GtkTreeView widget with the model initialized to @model.
11275  *
11276  * Return value: A newly created #GtkTreeView widget.
11277  **/
11278 GtkWidget *
11279 gtk_tree_view_new_with_model (GtkTreeModel *model)
11280 {
11281   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
11282 }
11283
11284 /* Public Accessors
11285  */
11286
11287 /**
11288  * gtk_tree_view_get_model:
11289  * @tree_view: a #GtkTreeView
11290  *
11291  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
11292  * model is unset.
11293  *
11294  * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
11295  **/
11296 GtkTreeModel *
11297 gtk_tree_view_get_model (GtkTreeView *tree_view)
11298 {
11299   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11300
11301   return tree_view->priv->model;
11302 }
11303
11304 /**
11305  * gtk_tree_view_set_model:
11306  * @tree_view: A #GtkTreeView.
11307  * @model: (allow-none): The model.
11308  *
11309  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
11310  * set, it will remove it before setting the new model.  If @model is %NULL,
11311  * then it will unset the old model.
11312  **/
11313 void
11314 gtk_tree_view_set_model (GtkTreeView  *tree_view,
11315                          GtkTreeModel *model)
11316 {
11317   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11318   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
11319
11320   if (model == tree_view->priv->model)
11321     return;
11322
11323   if (tree_view->priv->scroll_to_path)
11324     {
11325       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11326       tree_view->priv->scroll_to_path = NULL;
11327     }
11328
11329   if (tree_view->priv->rubber_band_status)
11330     gtk_tree_view_stop_rubber_band (tree_view);
11331
11332   if (tree_view->priv->model)
11333     {
11334       GList *tmplist = tree_view->priv->columns;
11335
11336       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
11337       gtk_tree_view_stop_editing (tree_view, TRUE);
11338
11339       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11340                                             gtk_tree_view_row_changed,
11341                                             tree_view);
11342       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11343                                             gtk_tree_view_row_inserted,
11344                                             tree_view);
11345       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11346                                             gtk_tree_view_row_has_child_toggled,
11347                                             tree_view);
11348       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11349                                             gtk_tree_view_row_deleted,
11350                                             tree_view);
11351       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11352                                             gtk_tree_view_rows_reordered,
11353                                             tree_view);
11354
11355       for (; tmplist; tmplist = tmplist->next)
11356         _gtk_tree_view_column_unset_model (tmplist->data,
11357                                            tree_view->priv->model);
11358
11359       if (tree_view->priv->tree)
11360         gtk_tree_view_free_rbtree (tree_view);
11361
11362       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
11363       tree_view->priv->drag_dest_row = NULL;
11364       gtk_tree_row_reference_free (tree_view->priv->anchor);
11365       tree_view->priv->anchor = NULL;
11366       gtk_tree_row_reference_free (tree_view->priv->top_row);
11367       tree_view->priv->top_row = NULL;
11368       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11369       tree_view->priv->scroll_to_path = NULL;
11370
11371       tree_view->priv->scroll_to_column = NULL;
11372
11373       g_object_unref (tree_view->priv->model);
11374
11375       tree_view->priv->search_column = -1;
11376       tree_view->priv->fixed_height_check = 0;
11377       tree_view->priv->fixed_height = -1;
11378       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
11379       tree_view->priv->last_button_x = -1;
11380       tree_view->priv->last_button_y = -1;
11381     }
11382
11383   tree_view->priv->model = model;
11384
11385   if (tree_view->priv->model)
11386     {
11387       gint i;
11388       GtkTreePath *path;
11389       GtkTreeIter iter;
11390       GtkTreeModelFlags flags;
11391
11392       if (tree_view->priv->search_column == -1)
11393         {
11394           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
11395             {
11396               GType type = gtk_tree_model_get_column_type (model, i);
11397
11398               if (g_value_type_transformable (type, G_TYPE_STRING))
11399                 {
11400                   tree_view->priv->search_column = i;
11401                   break;
11402                 }
11403             }
11404         }
11405
11406       g_object_ref (tree_view->priv->model);
11407       g_signal_connect (tree_view->priv->model,
11408                         "row-changed",
11409                         G_CALLBACK (gtk_tree_view_row_changed),
11410                         tree_view);
11411       g_signal_connect (tree_view->priv->model,
11412                         "row-inserted",
11413                         G_CALLBACK (gtk_tree_view_row_inserted),
11414                         tree_view);
11415       g_signal_connect (tree_view->priv->model,
11416                         "row-has-child-toggled",
11417                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
11418                         tree_view);
11419       g_signal_connect (tree_view->priv->model,
11420                         "row-deleted",
11421                         G_CALLBACK (gtk_tree_view_row_deleted),
11422                         tree_view);
11423       g_signal_connect (tree_view->priv->model,
11424                         "rows-reordered",
11425                         G_CALLBACK (gtk_tree_view_rows_reordered),
11426                         tree_view);
11427
11428       flags = gtk_tree_model_get_flags (tree_view->priv->model);
11429       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
11430         tree_view->priv->is_list = TRUE;
11431       else
11432         tree_view->priv->is_list = FALSE;
11433
11434       path = gtk_tree_path_new_first ();
11435       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
11436         {
11437           tree_view->priv->tree = _gtk_rbtree_new ();
11438           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
11439           _gtk_tree_view_accessible_add (tree_view, tree_view->priv->tree, NULL);
11440         }
11441       gtk_tree_path_free (path);
11442
11443       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
11444       install_presize_handler (tree_view);
11445     }
11446
11447   gtk_tree_view_real_set_cursor (tree_view, NULL, CURSOR_INVALID);
11448
11449   g_object_notify (G_OBJECT (tree_view), "model");
11450
11451   if (tree_view->priv->selection)
11452   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
11453
11454   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11455     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11456 }
11457
11458 /**
11459  * gtk_tree_view_get_selection:
11460  * @tree_view: A #GtkTreeView.
11461  *
11462  * Gets the #GtkTreeSelection associated with @tree_view.
11463  *
11464  * Return value: (transfer none): A #GtkTreeSelection object.
11465  **/
11466 GtkTreeSelection *
11467 gtk_tree_view_get_selection (GtkTreeView *tree_view)
11468 {
11469   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11470
11471   return tree_view->priv->selection;
11472 }
11473
11474 /**
11475  * gtk_tree_view_get_hadjustment:
11476  * @tree_view: A #GtkTreeView
11477  *
11478  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
11479  *
11480  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11481  *     if none is currently being used.
11482  *
11483  * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment()
11484  **/
11485 GtkAdjustment *
11486 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
11487 {
11488   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11489
11490   return gtk_tree_view_do_get_hadjustment (tree_view);
11491 }
11492
11493 static GtkAdjustment *
11494 gtk_tree_view_do_get_hadjustment (GtkTreeView *tree_view)
11495 {
11496   return tree_view->priv->hadjustment;
11497 }
11498
11499 /**
11500  * gtk_tree_view_set_hadjustment:
11501  * @tree_view: A #GtkTreeView
11502  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11503  *
11504  * Sets the #GtkAdjustment for the current horizontal aspect.
11505  *
11506  * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment()
11507  **/
11508 void
11509 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
11510                                GtkAdjustment *adjustment)
11511 {
11512   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11513   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11514
11515   gtk_tree_view_do_set_hadjustment (tree_view, adjustment);
11516 }
11517
11518 static void
11519 gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
11520                                   GtkAdjustment *adjustment)
11521 {
11522   GtkTreeViewPrivate *priv = tree_view->priv;
11523
11524   if (adjustment && priv->hadjustment == adjustment)
11525     return;
11526
11527   if (priv->hadjustment != NULL)
11528     {
11529       g_signal_handlers_disconnect_by_func (priv->hadjustment,
11530                                             gtk_tree_view_adjustment_changed,
11531                                             tree_view);
11532       g_object_unref (priv->hadjustment);
11533     }
11534
11535   if (adjustment == NULL)
11536     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11537                                      0.0, 0.0, 0.0);
11538
11539   g_signal_connect (adjustment, "value-changed",
11540                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11541   priv->hadjustment = g_object_ref_sink (adjustment);
11542   /* FIXME: Adjustment should probably be populated here with fresh values, but
11543    * internal details are too complicated for me to decipher right now.
11544    */
11545   gtk_tree_view_adjustment_changed (NULL, tree_view);
11546
11547   g_object_notify (G_OBJECT (tree_view), "hadjustment");
11548 }
11549
11550 /**
11551  * gtk_tree_view_get_vadjustment:
11552  * @tree_view: A #GtkTreeView
11553  *
11554  * Gets the #GtkAdjustment currently being used for the vertical aspect.
11555  *
11556  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11557  *     if none is currently being used.
11558  *
11559  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
11560  **/
11561 GtkAdjustment *
11562 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
11563 {
11564   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11565
11566   return gtk_tree_view_do_get_vadjustment (tree_view);
11567 }
11568
11569 static GtkAdjustment *
11570 gtk_tree_view_do_get_vadjustment (GtkTreeView *tree_view)
11571 {
11572   return tree_view->priv->vadjustment;
11573 }
11574
11575 /**
11576  * gtk_tree_view_set_vadjustment:
11577  * @tree_view: A #GtkTreeView
11578  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11579  *
11580  * Sets the #GtkAdjustment for the current vertical aspect.
11581  *
11582  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
11583  **/
11584 void
11585 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
11586                                GtkAdjustment *adjustment)
11587 {
11588   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11589   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11590
11591   gtk_tree_view_do_set_vadjustment (tree_view, adjustment);
11592 }
11593
11594 static void
11595 gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
11596                                   GtkAdjustment *adjustment)
11597 {
11598   GtkTreeViewPrivate *priv = tree_view->priv;
11599
11600   if (adjustment && priv->vadjustment == adjustment)
11601     return;
11602
11603   if (priv->vadjustment != NULL)
11604     {
11605       g_signal_handlers_disconnect_by_func (priv->vadjustment,
11606                                             gtk_tree_view_adjustment_changed,
11607                                             tree_view);
11608       g_object_unref (priv->vadjustment);
11609     }
11610
11611   if (adjustment == NULL)
11612     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11613                                      0.0, 0.0, 0.0);
11614
11615   g_signal_connect (adjustment, "value-changed",
11616                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11617   priv->vadjustment = g_object_ref_sink (adjustment);
11618   /* FIXME: Adjustment should probably be populated here with fresh values, but
11619    * internal details are too complicated for me to decipher right now.
11620    */
11621   gtk_tree_view_adjustment_changed (NULL, tree_view);
11622   g_object_notify (G_OBJECT (tree_view), "vadjustment");
11623 }
11624
11625 /* Column and header operations */
11626
11627 /**
11628  * gtk_tree_view_get_headers_visible:
11629  * @tree_view: A #GtkTreeView.
11630  *
11631  * Returns %TRUE if the headers on the @tree_view are visible.
11632  *
11633  * Return value: Whether the headers are visible or not.
11634  **/
11635 gboolean
11636 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
11637 {
11638   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11639
11640   return tree_view->priv->headers_visible;
11641 }
11642
11643 /**
11644  * gtk_tree_view_set_headers_visible:
11645  * @tree_view: A #GtkTreeView.
11646  * @headers_visible: %TRUE if the headers are visible
11647  *
11648  * Sets the visibility state of the headers.
11649  **/
11650 void
11651 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
11652                                    gboolean     headers_visible)
11653 {
11654   gint x, y;
11655   GList *list;
11656   GtkTreeViewColumn *column;
11657   GtkAllocation allocation;
11658   GtkWidget *button;
11659
11660   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11661
11662   headers_visible = !! headers_visible;
11663
11664   if (tree_view->priv->headers_visible == headers_visible)
11665     return;
11666
11667   tree_view->priv->headers_visible = headers_visible == TRUE;
11668
11669   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11670     {
11671       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
11672       if (headers_visible)
11673         {
11674           gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11675           gdk_window_move_resize (tree_view->priv->bin_window,
11676                                   x, y  + gtk_tree_view_get_effective_header_height (tree_view),
11677                                   tree_view->priv->width, allocation.height -  + gtk_tree_view_get_effective_header_height (tree_view));
11678
11679           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
11680             gtk_tree_view_map_buttons (tree_view);
11681         }
11682       else
11683         {
11684           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
11685
11686           for (list = tree_view->priv->columns; list; list = list->next)
11687             {
11688               column = list->data;
11689               button = gtk_tree_view_column_get_button (column);
11690
11691               gtk_widget_hide (button);
11692               gtk_widget_unmap (button);
11693             }
11694           gdk_window_hide (tree_view->priv->header_window);
11695         }
11696     }
11697
11698   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11699   gtk_adjustment_configure (tree_view->priv->vadjustment,
11700                             gtk_adjustment_get_value (tree_view->priv->vadjustment),
11701                             0,
11702                             tree_view->priv->height,
11703                             gtk_adjustment_get_step_increment (tree_view->priv->vadjustment),
11704                             (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2,
11705                             allocation.height - gtk_tree_view_get_effective_header_height (tree_view));
11706
11707   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11708
11709   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11710 }
11711
11712 /**
11713  * gtk_tree_view_columns_autosize:
11714  * @tree_view: A #GtkTreeView.
11715  *
11716  * Resizes all columns to their optimal width. Only works after the
11717  * treeview has been realized.
11718  **/
11719 void
11720 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11721 {
11722   gboolean dirty = FALSE;
11723   GList *list;
11724   GtkTreeViewColumn *column;
11725
11726   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11727
11728   for (list = tree_view->priv->columns; list; list = list->next)
11729     {
11730       column = list->data;
11731       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11732         continue;
11733       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11734       dirty = TRUE;
11735     }
11736
11737   if (dirty)
11738     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11739 }
11740
11741 /**
11742  * gtk_tree_view_set_headers_clickable:
11743  * @tree_view: A #GtkTreeView.
11744  * @setting: %TRUE if the columns are clickable.
11745  *
11746  * Allow the column title buttons to be clicked.
11747  **/
11748 void
11749 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11750                                      gboolean   setting)
11751 {
11752   GList *list;
11753
11754   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11755
11756   for (list = tree_view->priv->columns; list; list = list->next)
11757     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11758
11759   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11760 }
11761
11762
11763 /**
11764  * gtk_tree_view_get_headers_clickable:
11765  * @tree_view: A #GtkTreeView.
11766  *
11767  * Returns whether all header columns are clickable.
11768  *
11769  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11770  *
11771  * Since: 2.10
11772  **/
11773 gboolean
11774 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11775 {
11776   GList *list;
11777
11778   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11779
11780   for (list = tree_view->priv->columns; list; list = list->next)
11781     if (!gtk_tree_view_column_get_clickable (GTK_TREE_VIEW_COLUMN (list->data)))
11782       return FALSE;
11783
11784   return TRUE;
11785 }
11786
11787 /**
11788  * gtk_tree_view_set_rules_hint:
11789  * @tree_view: a #GtkTreeView
11790  * @setting: %TRUE if the tree requires reading across rows
11791  *
11792  * This function tells GTK+ that the user interface for your
11793  * application requires users to read across tree rows and associate
11794  * cells with one another. By default, GTK+ will then render the tree
11795  * with alternating row colors. Do <emphasis>not</emphasis> use it
11796  * just because you prefer the appearance of the ruled tree; that's a
11797  * question for the theme. Some themes will draw tree rows in
11798  * alternating colors even when rules are turned off, and users who
11799  * prefer that appearance all the time can choose those themes. You
11800  * should call this function only as a <emphasis>semantic</emphasis>
11801  * hint to the theme engine that your tree makes alternating colors
11802  * useful from a functional standpoint (since it has lots of columns,
11803  * generally).
11804  *
11805  **/
11806 void
11807 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11808                               gboolean      setting)
11809 {
11810   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11811
11812   setting = setting != FALSE;
11813
11814   if (tree_view->priv->has_rules != setting)
11815     {
11816       tree_view->priv->has_rules = setting;
11817       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11818     }
11819
11820   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11821 }
11822
11823 /**
11824  * gtk_tree_view_get_rules_hint:
11825  * @tree_view: a #GtkTreeView
11826  *
11827  * Gets the setting set by gtk_tree_view_set_rules_hint().
11828  *
11829  * Return value: %TRUE if rules are useful for the user of this tree
11830  **/
11831 gboolean
11832 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11833 {
11834   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11835
11836   return tree_view->priv->has_rules;
11837 }
11838
11839
11840 /**
11841  * gtk_tree_view_set_activate_on_single_click:
11842  * @tree_view: a #GtkTreeView
11843  * @single: %TRUE to emit row-activated on a single click
11844  *
11845  * Cause the #GtkTreeView::row-activated signal to be emitted
11846  * on a single click instead of a double click.
11847  *
11848  * Since: 3.8
11849  **/
11850 void
11851 gtk_tree_view_set_activate_on_single_click (GtkTreeView *tree_view,
11852                                             gboolean     single)
11853 {
11854   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11855
11856   single = single != FALSE;
11857
11858   if (tree_view->priv->activate_on_single_click == single)
11859     return;
11860
11861   tree_view->priv->activate_on_single_click = single;
11862   g_object_notify (G_OBJECT (tree_view), "activate-on-single-click");
11863 }
11864
11865 /**
11866  * gtk_tree_view_get_activate_on_single_click:
11867  * @tree_view: a #GtkTreeView
11868  *
11869  * Gets the setting set by gtk_tree_view_set_activate_on_single_click().
11870  *
11871  * Return value: %TRUE if row-activated will be emitted on a single click
11872  *
11873  * Since: 3.8
11874  **/
11875 gboolean
11876 gtk_tree_view_get_activate_on_single_click (GtkTreeView *tree_view)
11877 {
11878   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11879
11880   return tree_view->priv->activate_on_single_click;
11881 }
11882
11883 /* Public Column functions
11884  */
11885
11886 /**
11887  * gtk_tree_view_append_column:
11888  * @tree_view: A #GtkTreeView.
11889  * @column: The #GtkTreeViewColumn to add.
11890  *
11891  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11892  * mode enabled, then @column must have its "sizing" property set to be
11893  * GTK_TREE_VIEW_COLUMN_FIXED.
11894  *
11895  * Return value: The number of columns in @tree_view after appending.
11896  **/
11897 gint
11898 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11899                              GtkTreeViewColumn *column)
11900 {
11901   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11902   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11903   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11904
11905   return gtk_tree_view_insert_column (tree_view, column, -1);
11906 }
11907
11908 void
11909 _gtk_tree_view_reset_header_styles (GtkTreeView *tree_view)
11910 {
11911   GList *columns;
11912
11913   for (columns = tree_view->priv->columns; columns; columns = columns->next)
11914     {
11915       GtkTreeViewColumn *column = columns->data;
11916       GtkWidget *header_widget;
11917
11918       if (!gtk_tree_view_column_get_visible (column))
11919         continue;
11920
11921       header_widget = gtk_tree_view_column_get_widget (column);
11922
11923       if (!header_widget)
11924         header_widget = gtk_tree_view_column_get_button (column);
11925
11926       _gtk_widget_invalidate_style_context (header_widget, GTK_CSS_CHANGE_PARENT_REGION);
11927     }
11928 }
11929
11930
11931 /**
11932  * gtk_tree_view_remove_column:
11933  * @tree_view: A #GtkTreeView.
11934  * @column: The #GtkTreeViewColumn to remove.
11935  *
11936  * Removes @column from @tree_view.
11937  *
11938  * Return value: The number of columns in @tree_view after removing.
11939  **/
11940 gint
11941 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11942                              GtkTreeViewColumn *column)
11943 {
11944   guint position;
11945
11946   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11947   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11948   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1);
11949
11950   if (tree_view->priv->focus_column == column)
11951     _gtk_tree_view_set_focus_column (tree_view, NULL);
11952
11953   if (tree_view->priv->edited_column == column)
11954     {
11955       gtk_tree_view_stop_editing (tree_view, TRUE);
11956
11957       /* no need to, but just to be sure ... */
11958       tree_view->priv->edited_column = NULL;
11959     }
11960
11961   if (tree_view->priv->expander_column == column)
11962     tree_view->priv->expander_column = NULL;
11963
11964   g_signal_handlers_disconnect_by_func (column,
11965                                         G_CALLBACK (column_sizing_notify),
11966                                         tree_view);
11967
11968   position = g_list_index (tree_view->priv->columns, column);
11969
11970   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11971   tree_view->priv->n_columns--;
11972
11973   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11974     {
11975       GList *list;
11976
11977       _gtk_tree_view_column_unrealize_button (column);
11978       for (list = tree_view->priv->columns; list; list = list->next)
11979         {
11980           GtkTreeViewColumn *tmp_column;
11981
11982           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11983           if (gtk_tree_view_column_get_visible (tmp_column))
11984             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
11985         }
11986
11987       if (tree_view->priv->n_columns == 0 &&
11988           gtk_tree_view_get_headers_visible (tree_view))
11989         gdk_window_hide (tree_view->priv->header_window);
11990
11991       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11992     }
11993
11994   _gtk_tree_view_reset_header_styles (tree_view);
11995   _gtk_tree_view_column_unset_tree_view (column);
11996   _gtk_tree_view_accessible_remove_column (tree_view, column, position);
11997
11998   g_object_unref (column);
11999   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12000
12001   return tree_view->priv->n_columns;
12002 }
12003
12004 /**
12005  * gtk_tree_view_insert_column:
12006  * @tree_view: A #GtkTreeView.
12007  * @column: The #GtkTreeViewColumn to be inserted.
12008  * @position: The position to insert @column in.
12009  *
12010  * This inserts the @column into the @tree_view at @position.  If @position is
12011  * -1, then the column is inserted at the end. If @tree_view has
12012  * "fixed_height" mode enabled, then @column must have its "sizing" property
12013  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
12014  *
12015  * Return value: The number of columns in @tree_view after insertion.
12016  **/
12017 gint
12018 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
12019                              GtkTreeViewColumn *column,
12020                              gint               position)
12021 {
12022   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12023   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
12024   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
12025
12026   if (tree_view->priv->fixed_height_mode)
12027     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
12028                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
12029
12030   if (position < 0 || position > tree_view->priv->n_columns)
12031     position = tree_view->priv->n_columns;
12032
12033   g_object_ref_sink (column);
12034
12035   if (tree_view->priv->n_columns == 0 &&
12036       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
12037       gtk_tree_view_get_headers_visible (tree_view))
12038     {
12039       gdk_window_show (tree_view->priv->header_window);
12040     }
12041
12042   g_signal_connect (column, "notify::sizing",
12043                     G_CALLBACK (column_sizing_notify), tree_view);
12044
12045   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
12046                                             column, position);
12047   tree_view->priv->n_columns++;
12048
12049   _gtk_tree_view_column_set_tree_view (column, tree_view);
12050
12051   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12052     {
12053       GList *list;
12054
12055       _gtk_tree_view_column_realize_button (column);
12056
12057       for (list = tree_view->priv->columns; list; list = list->next)
12058         {
12059           column = GTK_TREE_VIEW_COLUMN (list->data);
12060           if (gtk_tree_view_column_get_visible (column))
12061             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12062         }
12063       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12064     }
12065
12066   _gtk_tree_view_reset_header_styles (tree_view);
12067
12068   _gtk_tree_view_accessible_add_column (tree_view, column, position);
12069
12070   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12071
12072   return tree_view->priv->n_columns;
12073 }
12074
12075 /**
12076  * gtk_tree_view_insert_column_with_attributes:
12077  * @tree_view: A #GtkTreeView
12078  * @position: The position to insert the new column in
12079  * @title: The title to set the header to
12080  * @cell: The #GtkCellRenderer
12081  * @...: A %NULL-terminated list of attributes
12082  *
12083  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
12084  * @position.  If @position is -1, then the newly created column is inserted at
12085  * the end.  The column is initialized with the attributes given. If @tree_view
12086  * has "fixed_height" mode enabled, then the new column will have its sizing
12087  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12088  *
12089  * Return value: The number of columns in @tree_view after insertion.
12090  **/
12091 gint
12092 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
12093                                              gint             position,
12094                                              const gchar     *title,
12095                                              GtkCellRenderer *cell,
12096                                              ...)
12097 {
12098   GtkTreeViewColumn *column;
12099   gchar *attribute;
12100   va_list args;
12101   gint column_id;
12102
12103   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12104
12105   column = gtk_tree_view_column_new ();
12106   if (tree_view->priv->fixed_height_mode)
12107     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12108
12109   gtk_tree_view_column_set_title (column, title);
12110   gtk_tree_view_column_pack_start (column, cell, TRUE);
12111
12112   va_start (args, cell);
12113
12114   attribute = va_arg (args, gchar *);
12115
12116   while (attribute != NULL)
12117     {
12118       column_id = va_arg (args, gint);
12119       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
12120       attribute = va_arg (args, gchar *);
12121     }
12122
12123   va_end (args);
12124
12125   return gtk_tree_view_insert_column (tree_view, column, position);
12126 }
12127
12128 /**
12129  * gtk_tree_view_insert_column_with_data_func:
12130  * @tree_view: a #GtkTreeView
12131  * @position: Position to insert, -1 for append
12132  * @title: column title
12133  * @cell: cell renderer for column
12134  * @func: function to set attributes of cell renderer
12135  * @data: data for @func
12136  * @dnotify: destroy notifier for @data
12137  *
12138  * Convenience function that inserts a new column into the #GtkTreeView
12139  * with the given cell renderer and a #GtkTreeCellDataFunc to set cell renderer
12140  * attributes (normally using data from the model). See also
12141  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
12142  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
12143  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12144  *
12145  * Return value: number of columns in the tree view post-insert
12146  **/
12147 gint
12148 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
12149                                              gint                       position,
12150                                              const gchar               *title,
12151                                              GtkCellRenderer           *cell,
12152                                              GtkTreeCellDataFunc        func,
12153                                              gpointer                   data,
12154                                              GDestroyNotify             dnotify)
12155 {
12156   GtkTreeViewColumn *column;
12157
12158   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12159
12160   column = gtk_tree_view_column_new ();
12161   if (tree_view->priv->fixed_height_mode)
12162     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12163
12164   gtk_tree_view_column_set_title (column, title);
12165   gtk_tree_view_column_pack_start (column, cell, TRUE);
12166   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
12167
12168   return gtk_tree_view_insert_column (tree_view, column, position);
12169 }
12170
12171 /**
12172  * gtk_tree_view_get_n_columns:
12173  * @tree_view: a #GtkTreeView
12174  *
12175  * Queries the number of columns in the given @tree_view.
12176  *
12177  * Returns: The number of columns in the @tree_view
12178  *
12179  * Since: 3.4
12180  **/
12181 guint
12182 gtk_tree_view_get_n_columns (GtkTreeView *tree_view)
12183 {
12184   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
12185
12186   return tree_view->priv->n_columns;
12187 }
12188
12189 /**
12190  * gtk_tree_view_get_column:
12191  * @tree_view: A #GtkTreeView.
12192  * @n: The position of the column, counting from 0.
12193  *
12194  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
12195  *
12196  * Return value: (transfer none): The #GtkTreeViewColumn, or %NULL if the
12197  *     position is outside the range of columns.
12198  **/
12199 GtkTreeViewColumn *
12200 gtk_tree_view_get_column (GtkTreeView *tree_view,
12201                           gint         n)
12202 {
12203   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12204
12205   if (n < 0 || n >= tree_view->priv->n_columns)
12206     return NULL;
12207
12208   if (tree_view->priv->columns == NULL)
12209     return NULL;
12210
12211   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
12212 }
12213
12214 /**
12215  * gtk_tree_view_get_columns:
12216  * @tree_view: A #GtkTreeView
12217  *
12218  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
12219  * The returned list must be freed with g_list_free ().
12220  *
12221  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
12222  **/
12223 GList *
12224 gtk_tree_view_get_columns (GtkTreeView *tree_view)
12225 {
12226   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12227
12228   return g_list_copy (tree_view->priv->columns);
12229 }
12230
12231 /**
12232  * gtk_tree_view_move_column_after:
12233  * @tree_view: A #GtkTreeView
12234  * @column: The #GtkTreeViewColumn to be moved.
12235  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
12236  *
12237  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
12238  * @column is placed in the first position.
12239  **/
12240 void
12241 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
12242                                  GtkTreeViewColumn *column,
12243                                  GtkTreeViewColumn *base_column)
12244 {
12245   GList *column_list_el, *base_el = NULL;
12246
12247   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12248
12249   column_list_el = g_list_find (tree_view->priv->columns, column);
12250   g_return_if_fail (column_list_el != NULL);
12251
12252   if (base_column)
12253     {
12254       base_el = g_list_find (tree_view->priv->columns, base_column);
12255       g_return_if_fail (base_el != NULL);
12256     }
12257
12258   if (column_list_el->prev == base_el)
12259     return;
12260
12261   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
12262   if (base_el == NULL)
12263     {
12264       column_list_el->prev = NULL;
12265       column_list_el->next = tree_view->priv->columns;
12266       if (column_list_el->next)
12267         column_list_el->next->prev = column_list_el;
12268       tree_view->priv->columns = column_list_el;
12269     }
12270   else
12271     {
12272       column_list_el->prev = base_el;
12273       column_list_el->next = base_el->next;
12274       if (column_list_el->next)
12275         column_list_el->next->prev = column_list_el;
12276       base_el->next = column_list_el;
12277     }
12278
12279   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12280     {
12281       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12282       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
12283     }
12284
12285   _gtk_tree_view_reset_header_styles (tree_view);
12286
12287   _gtk_tree_view_accessible_reorder_column (tree_view, column);
12288
12289   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12290 }
12291
12292 /**
12293  * gtk_tree_view_set_expander_column:
12294  * @tree_view: A #GtkTreeView
12295  * @column: %NULL, or the column to draw the expander arrow at.
12296  *
12297  * Sets the column to draw the expander arrow at. It must be in @tree_view.
12298  * If @column is %NULL, then the expander arrow is always at the first
12299  * visible column.
12300  *
12301  * If you do not want expander arrow to appear in your tree, set the
12302  * expander column to a hidden column.
12303  **/
12304 void
12305 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
12306                                    GtkTreeViewColumn *column)
12307 {
12308   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12309   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12310   g_return_if_fail (column == NULL || gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view));
12311
12312   if (tree_view->priv->expander_column != column)
12313     {
12314       tree_view->priv->expander_column = column;
12315       g_object_notify (G_OBJECT (tree_view), "expander-column");
12316     }
12317 }
12318
12319 /**
12320  * gtk_tree_view_get_expander_column:
12321  * @tree_view: A #GtkTreeView
12322  *
12323  * Returns the column that is the current expander column.
12324  * This column has the expander arrow drawn next to it.
12325  *
12326  * Return value: (transfer none): The expander column.
12327  **/
12328 GtkTreeViewColumn *
12329 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
12330 {
12331   GList *list;
12332
12333   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12334
12335   for (list = tree_view->priv->columns; list; list = list->next)
12336     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
12337       return (GtkTreeViewColumn *) list->data;
12338   return NULL;
12339 }
12340
12341
12342 /**
12343  * gtk_tree_view_set_column_drag_function:
12344  * @tree_view: A #GtkTreeView.
12345  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
12346  * @user_data: (allow-none): User data to be passed to @func, or %NULL
12347  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
12348  *
12349  * Sets a user function for determining where a column may be dropped when
12350  * dragged.  This function is called on every column pair in turn at the
12351  * beginning of a column drag to determine where a drop can take place.  The
12352  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
12353  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
12354  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
12355  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
12356  * @tree_view reverts to the default behavior of allowing all columns to be
12357  * dropped everywhere.
12358  **/
12359 void
12360 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
12361                                         GtkTreeViewColumnDropFunc  func,
12362                                         gpointer                   user_data,
12363                                         GDestroyNotify             destroy)
12364 {
12365   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12366
12367   if (tree_view->priv->column_drop_func_data_destroy)
12368     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
12369
12370   tree_view->priv->column_drop_func = func;
12371   tree_view->priv->column_drop_func_data = user_data;
12372   tree_view->priv->column_drop_func_data_destroy = destroy;
12373 }
12374
12375 /**
12376  * gtk_tree_view_scroll_to_point:
12377  * @tree_view: a #GtkTreeView
12378  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
12379  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
12380  *
12381  * Scrolls the tree view such that the top-left corner of the visible
12382  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
12383  * in tree coordinates.  The @tree_view must be realized before
12384  * this function is called.  If it isn't, you probably want to be
12385  * using gtk_tree_view_scroll_to_cell().
12386  *
12387  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
12388  **/
12389 void
12390 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
12391                                gint         tree_x,
12392                                gint         tree_y)
12393 {
12394   GtkAdjustment *hadj;
12395   GtkAdjustment *vadj;
12396
12397   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12398   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
12399
12400   hadj = tree_view->priv->hadjustment;
12401   vadj = tree_view->priv->vadjustment;
12402
12403   if (tree_x != -1)
12404     gtk_adjustment_set_value (hadj, tree_x);
12405   if (tree_y != -1)
12406     gtk_adjustment_set_value (vadj, tree_y);
12407 }
12408
12409 /**
12410  * gtk_tree_view_scroll_to_cell:
12411  * @tree_view: A #GtkTreeView.
12412  * @path: (allow-none): The path of the row to move to, or %NULL.
12413  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
12414  * @use_align: whether to use alignment arguments, or %FALSE.
12415  * @row_align: The vertical alignment of the row specified by @path.
12416  * @col_align: The horizontal alignment of the column specified by @column.
12417  *
12418  * Moves the alignments of @tree_view to the position specified by @column and
12419  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
12420  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
12421  * or @path need to be non-%NULL.  @row_align determines where the row is
12422  * placed, and @col_align determines where @column is placed.  Both are expected
12423  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
12424  * right/bottom alignment, 0.5 means center.
12425  *
12426  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
12427  * tree does the minimum amount of work to scroll the cell onto the screen.
12428  * This means that the cell will be scrolled to the edge closest to its current
12429  * position.  If the cell is currently visible on the screen, nothing is done.
12430  *
12431  * This function only works if the model is set, and @path is a valid row on the
12432  * model.  If the model changes before the @tree_view is realized, the centered
12433  * path will be modified to reflect this change.
12434  **/
12435 void
12436 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
12437                               GtkTreePath       *path,
12438                               GtkTreeViewColumn *column,
12439                               gboolean           use_align,
12440                               gfloat             row_align,
12441                               gfloat             col_align)
12442 {
12443   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12444   g_return_if_fail (tree_view->priv->model != NULL);
12445   g_return_if_fail (tree_view->priv->tree != NULL);
12446   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
12447   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
12448   g_return_if_fail (path != NULL || column != NULL);
12449
12450 #if 0
12451   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
12452            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
12453 #endif
12454   row_align = CLAMP (row_align, 0.0, 1.0);
12455   col_align = CLAMP (col_align, 0.0, 1.0);
12456
12457
12458   /* Note: Despite the benefits that come from having one code path for the
12459    * scrolling code, we short-circuit validate_visible_area's immplementation as
12460    * it is much slower than just going to the point.
12461    */
12462   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
12463       !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
12464       _gtk_widget_get_alloc_needed (GTK_WIDGET (tree_view)) ||
12465       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
12466     {
12467       if (tree_view->priv->scroll_to_path)
12468         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
12469
12470       tree_view->priv->scroll_to_path = NULL;
12471       tree_view->priv->scroll_to_column = NULL;
12472
12473       if (path)
12474         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
12475       if (column)
12476         tree_view->priv->scroll_to_column = column;
12477       tree_view->priv->scroll_to_use_align = use_align;
12478       tree_view->priv->scroll_to_row_align = row_align;
12479       tree_view->priv->scroll_to_col_align = col_align;
12480
12481       install_presize_handler (tree_view);
12482     }
12483   else
12484     {
12485       GdkRectangle cell_rect;
12486       GdkRectangle vis_rect;
12487       gint dest_x, dest_y;
12488
12489       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
12490       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
12491
12492       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
12493
12494       dest_x = vis_rect.x;
12495       dest_y = vis_rect.y;
12496
12497       if (column)
12498         {
12499           if (use_align)
12500             {
12501               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
12502             }
12503           else
12504             {
12505               if (cell_rect.x < vis_rect.x)
12506                 dest_x = cell_rect.x;
12507               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
12508                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
12509             }
12510         }
12511
12512       if (path)
12513         {
12514           if (use_align)
12515             {
12516               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
12517               dest_y = MAX (dest_y, 0);
12518             }
12519           else
12520             {
12521               if (cell_rect.y < vis_rect.y)
12522                 dest_y = cell_rect.y;
12523               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
12524                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
12525             }
12526         }
12527
12528       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
12529     }
12530 }
12531
12532 /**
12533  * gtk_tree_view_row_activated:
12534  * @tree_view: A #GtkTreeView
12535  * @path: The #GtkTreePath to be activated.
12536  * @column: The #GtkTreeViewColumn to be activated.
12537  *
12538  * Activates the cell determined by @path and @column.
12539  **/
12540 void
12541 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
12542                              GtkTreePath       *path,
12543                              GtkTreeViewColumn *column)
12544 {
12545   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12546
12547   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
12548 }
12549
12550
12551 static void
12552 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
12553                                           GtkRBNode *node,
12554                                           gpointer   data)
12555 {
12556   GtkTreeView *tree_view = data;
12557
12558   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
12559       node->children)
12560     {
12561       GtkTreePath *path;
12562       GtkTreeIter iter;
12563
12564       path = _gtk_tree_path_new_from_rbtree (tree, node);
12565       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12566
12567       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12568
12569       gtk_tree_path_free (path);
12570     }
12571
12572   if (node->children)
12573     _gtk_rbtree_traverse (node->children,
12574                           node->children->root,
12575                           G_PRE_ORDER,
12576                           gtk_tree_view_expand_all_emission_helper,
12577                           tree_view);
12578 }
12579
12580 /**
12581  * gtk_tree_view_expand_all:
12582  * @tree_view: A #GtkTreeView.
12583  *
12584  * Recursively expands all nodes in the @tree_view.
12585  **/
12586 void
12587 gtk_tree_view_expand_all (GtkTreeView *tree_view)
12588 {
12589   GtkTreePath *path;
12590   GtkRBTree *tree;
12591   GtkRBNode *node;
12592
12593   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12594
12595   if (tree_view->priv->tree == NULL)
12596     return;
12597
12598   path = gtk_tree_path_new_first ();
12599   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12600
12601   while (node)
12602     {
12603       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
12604       node = _gtk_rbtree_next (tree, node);
12605       gtk_tree_path_next (path);
12606   }
12607
12608   gtk_tree_path_free (path);
12609 }
12610
12611 /**
12612  * gtk_tree_view_collapse_all:
12613  * @tree_view: A #GtkTreeView.
12614  *
12615  * Recursively collapses all visible, expanded nodes in @tree_view.
12616  **/
12617 void
12618 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
12619 {
12620   GtkRBTree *tree;
12621   GtkRBNode *node;
12622   GtkTreePath *path;
12623   gint *indices;
12624
12625   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12626
12627   if (tree_view->priv->tree == NULL)
12628     return;
12629
12630   path = gtk_tree_path_new ();
12631   gtk_tree_path_down (path);
12632   indices = gtk_tree_path_get_indices (path);
12633
12634   tree = tree_view->priv->tree;
12635   node = _gtk_rbtree_first (tree);
12636
12637   while (node)
12638     {
12639       if (node->children)
12640         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12641       indices[0]++;
12642       node = _gtk_rbtree_next (tree, node);
12643     }
12644
12645   gtk_tree_path_free (path);
12646 }
12647
12648 /**
12649  * gtk_tree_view_expand_to_path:
12650  * @tree_view: A #GtkTreeView.
12651  * @path: path to a row.
12652  *
12653  * Expands the row at @path. This will also expand all parent rows of
12654  * @path as necessary.
12655  *
12656  * Since: 2.2
12657  **/
12658 void
12659 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
12660                               GtkTreePath *path)
12661 {
12662   gint i, depth;
12663   gint *indices;
12664   GtkTreePath *tmp;
12665
12666   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12667   g_return_if_fail (path != NULL);
12668
12669   depth = gtk_tree_path_get_depth (path);
12670   indices = gtk_tree_path_get_indices (path);
12671
12672   tmp = gtk_tree_path_new ();
12673   g_return_if_fail (tmp != NULL);
12674
12675   for (i = 0; i < depth; i++)
12676     {
12677       gtk_tree_path_append_index (tmp, indices[i]);
12678       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12679     }
12680
12681   gtk_tree_path_free (tmp);
12682 }
12683
12684 /* FIXME the bool return values for expand_row and collapse_row are
12685  * not analagous; they should be TRUE if the row had children and
12686  * was not already in the requested state.
12687  */
12688
12689
12690 static gboolean
12691 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12692                                GtkTreePath *path,
12693                                GtkRBTree   *tree,
12694                                GtkRBNode   *node,
12695                                gboolean     open_all,
12696                                gboolean     animate)
12697 {
12698   GtkTreeIter iter;
12699   GtkTreeIter temp;
12700   gboolean expand;
12701
12702   if (animate)
12703     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12704                   "gtk-enable-animations", &animate,
12705                   NULL);
12706
12707   remove_auto_expand_timeout (tree_view);
12708
12709   if (node->children && !open_all)
12710     return FALSE;
12711
12712   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12713     return FALSE;
12714
12715   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12716   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12717     return FALSE;
12718
12719
12720    if (node->children && open_all)
12721     {
12722       gboolean retval = FALSE;
12723       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12724
12725       gtk_tree_path_append_index (tmp_path, 0);
12726       tree = node->children;
12727       node = _gtk_rbtree_first (tree);
12728       /* try to expand the children */
12729       do
12730         {
12731          gboolean t;
12732          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12733                                             TRUE, animate);
12734          if (t)
12735            retval = TRUE;
12736
12737          gtk_tree_path_next (tmp_path);
12738          node = _gtk_rbtree_next (tree, node);
12739        }
12740       while (node != NULL);
12741
12742       gtk_tree_path_free (tmp_path);
12743
12744       return retval;
12745     }
12746
12747   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12748
12749   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12750     return FALSE;
12751
12752   if (expand)
12753     return FALSE;
12754
12755   node->children = _gtk_rbtree_new ();
12756   node->children->parent_tree = tree;
12757   node->children->parent_node = node;
12758
12759   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12760
12761   gtk_tree_view_build_tree (tree_view,
12762                             node->children,
12763                             &temp,
12764                             gtk_tree_path_get_depth (path) + 1,
12765                             open_all);
12766
12767   _gtk_tree_view_accessible_add (tree_view, node->children, NULL);
12768   _gtk_tree_view_accessible_add_state (tree_view,
12769                                        tree, node,
12770                                        GTK_CELL_RENDERER_EXPANDED);
12771
12772   install_presize_handler (tree_view);
12773
12774   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12775   if (open_all && node->children)
12776     {
12777       _gtk_rbtree_traverse (node->children,
12778                             node->children->root,
12779                             G_PRE_ORDER,
12780                             gtk_tree_view_expand_all_emission_helper,
12781                             tree_view);
12782     }
12783   return TRUE;
12784 }
12785
12786
12787 /**
12788  * gtk_tree_view_expand_row:
12789  * @tree_view: a #GtkTreeView
12790  * @path: path to a row
12791  * @open_all: whether to recursively expand, or just expand immediate children
12792  *
12793  * Opens the row so its children are visible.
12794  *
12795  * Return value: %TRUE if the row existed and had children
12796  **/
12797 gboolean
12798 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12799                           GtkTreePath *path,
12800                           gboolean     open_all)
12801 {
12802   GtkRBTree *tree;
12803   GtkRBNode *node;
12804
12805   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12806   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12807   g_return_val_if_fail (path != NULL, FALSE);
12808
12809   if (_gtk_tree_view_find_node (tree_view,
12810                                 path,
12811                                 &tree,
12812                                 &node))
12813     return FALSE;
12814
12815   if (tree != NULL)
12816     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12817   else
12818     return FALSE;
12819 }
12820
12821 static gboolean
12822 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12823                                  GtkTreePath *path,
12824                                  GtkRBTree   *tree,
12825                                  GtkRBNode   *node,
12826                                  gboolean     animate)
12827 {
12828   GtkTreeIter iter;
12829   GtkTreeIter children;
12830   gboolean collapse;
12831   gint x, y;
12832   GList *list;
12833   GdkWindow *child;
12834   gboolean selection_changed, cursor_changed;
12835
12836   if (animate)
12837     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12838                   "gtk-enable-animations", &animate,
12839                   NULL);
12840
12841   remove_auto_expand_timeout (tree_view);
12842
12843   if (node->children == NULL)
12844     return FALSE;
12845   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12846
12847   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12848
12849   if (collapse)
12850     return FALSE;
12851
12852   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12853    * a chance to prelight the correct node below */
12854
12855   if (tree_view->priv->prelight_tree)
12856     {
12857       GtkRBTree *parent_tree;
12858       GtkRBNode *parent_node;
12859
12860       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12861       parent_node = tree_view->priv->prelight_tree->parent_node;
12862       while (parent_tree)
12863         {
12864           if (parent_tree == tree && parent_node == node)
12865             {
12866               ensure_unprelighted (tree_view);
12867               break;
12868             }
12869           parent_node = parent_tree->parent_node;
12870           parent_tree = parent_tree->parent_tree;
12871         }
12872     }
12873
12874   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12875
12876   for (list = tree_view->priv->columns; list; list = list->next)
12877     {
12878       GtkTreeViewColumn *column = list->data;
12879
12880       if (gtk_tree_view_column_get_visible (column) == FALSE)
12881         continue;
12882       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12883         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12884     }
12885
12886   if (tree_view->priv->destroy_count_func)
12887     {
12888       GtkTreePath *child_path;
12889       gint child_count = 0;
12890       child_path = gtk_tree_path_copy (path);
12891       gtk_tree_path_down (child_path);
12892       if (node->children)
12893         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12894       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12895       gtk_tree_path_free (child_path);
12896     }
12897
12898   if (tree_view->priv->cursor_node)
12899     {
12900       cursor_changed = (node->children == tree_view->priv->cursor_tree)
12901                        || _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree);
12902     }
12903   else
12904     cursor_changed = FALSE;
12905
12906   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12907     {
12908       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12909       if (gtk_tree_path_is_ancestor (path, anchor_path))
12910         {
12911           gtk_tree_row_reference_free (tree_view->priv->anchor);
12912           tree_view->priv->anchor = NULL;
12913         }
12914       gtk_tree_path_free (anchor_path);
12915     }
12916
12917   selection_changed = gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children);
12918
12919   /* Stop a pending double click */
12920   tree_view->priv->last_button_x = -1;
12921   tree_view->priv->last_button_y = -1;
12922
12923   _gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
12924   _gtk_tree_view_accessible_remove_state (tree_view,
12925                                           tree, node,
12926                                           GTK_CELL_RENDERER_EXPANDED);
12927
12928   _gtk_rbtree_remove (node->children);
12929
12930   if (cursor_changed)
12931     gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CURSOR_INVALID);
12932   if (selection_changed)
12933     g_signal_emit_by_name (tree_view->priv->selection, "changed");
12934
12935   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12936     {
12937       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12938     }
12939
12940   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12941
12942   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12943     {
12944       /* now that we've collapsed all rows, we want to try to set the prelight
12945        * again. To do this, we fake a motion event and send it to ourselves. */
12946
12947       child = gdk_window_get_device_position (gdk_window_get_parent (tree_view->priv->bin_window),
12948                                               gdk_device_manager_get_client_pointer (
12949                                                 gdk_display_get_device_manager (
12950                                                   gtk_widget_get_display (GTK_WIDGET (tree_view)))),
12951                                               &x, &y, NULL);
12952       if (child == tree_view->priv->bin_window)
12953         {
12954           GdkEventMotion event;
12955           gint child_x, child_y;
12956
12957           gdk_window_get_position (child, &child_x, &child_y);
12958
12959           event.window = tree_view->priv->bin_window;
12960           event.x = x - child_x;
12961           event.y = y - child_y;
12962
12963           /* despite the fact this isn't a real event, I'm almost positive it will
12964            * never trigger a drag event.  maybe_drag is the only function that uses
12965            * more than just event.x and event.y. */
12966           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
12967         }
12968     }
12969
12970   return TRUE;
12971 }
12972
12973 /**
12974  * gtk_tree_view_collapse_row:
12975  * @tree_view: a #GtkTreeView
12976  * @path: path to a row in the @tree_view
12977  *
12978  * Collapses a row (hides its child rows, if they exist).
12979  *
12980  * Return value: %TRUE if the row was collapsed.
12981  **/
12982 gboolean
12983 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
12984                             GtkTreePath *path)
12985 {
12986   GtkRBTree *tree;
12987   GtkRBNode *node;
12988
12989   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12990   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
12991   g_return_val_if_fail (path != NULL, FALSE);
12992
12993   if (_gtk_tree_view_find_node (tree_view,
12994                                 path,
12995                                 &tree,
12996                                 &node))
12997     return FALSE;
12998
12999   if (tree == NULL || node->children == NULL)
13000     return FALSE;
13001
13002   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
13003 }
13004
13005 static void
13006 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
13007                                         GtkRBTree              *tree,
13008                                         GtkTreePath            *path,
13009                                         GtkTreeViewMappingFunc  func,
13010                                         gpointer                user_data)
13011 {
13012   GtkRBNode *node;
13013
13014   if (tree == NULL || tree->root == NULL)
13015     return;
13016
13017   node = _gtk_rbtree_first (tree);
13018
13019   while (node)
13020     {
13021       if (node->children)
13022         {
13023           (* func) (tree_view, path, user_data);
13024           gtk_tree_path_down (path);
13025           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
13026           gtk_tree_path_up (path);
13027         }
13028       gtk_tree_path_next (path);
13029       node = _gtk_rbtree_next (tree, node);
13030     }
13031 }
13032
13033 /**
13034  * gtk_tree_view_map_expanded_rows:
13035  * @tree_view: A #GtkTreeView
13036  * @func: (scope call): A function to be called
13037  * @data: User data to be passed to the function.
13038  *
13039  * Calls @func on all expanded rows.
13040  **/
13041 void
13042 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
13043                                  GtkTreeViewMappingFunc  func,
13044                                  gpointer                user_data)
13045 {
13046   GtkTreePath *path;
13047
13048   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13049   g_return_if_fail (func != NULL);
13050
13051   path = gtk_tree_path_new_first ();
13052
13053   gtk_tree_view_map_expanded_rows_helper (tree_view,
13054                                           tree_view->priv->tree,
13055                                           path, func, user_data);
13056
13057   gtk_tree_path_free (path);
13058 }
13059
13060 /**
13061  * gtk_tree_view_row_expanded:
13062  * @tree_view: A #GtkTreeView.
13063  * @path: A #GtkTreePath to test expansion state.
13064  *
13065  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
13066  *
13067  * Return value: %TRUE if #path is expanded.
13068  **/
13069 gboolean
13070 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
13071                             GtkTreePath *path)
13072 {
13073   GtkRBTree *tree;
13074   GtkRBNode *node;
13075
13076   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13077   g_return_val_if_fail (path != NULL, FALSE);
13078
13079   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13080
13081   if (node == NULL)
13082     return FALSE;
13083
13084   return (node->children != NULL);
13085 }
13086
13087 /**
13088  * gtk_tree_view_get_reorderable:
13089  * @tree_view: a #GtkTreeView
13090  *
13091  * Retrieves whether the user can reorder the tree via drag-and-drop. See
13092  * gtk_tree_view_set_reorderable().
13093  *
13094  * Return value: %TRUE if the tree can be reordered.
13095  **/
13096 gboolean
13097 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
13098 {
13099   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13100
13101   return tree_view->priv->reorderable;
13102 }
13103
13104 /**
13105  * gtk_tree_view_set_reorderable:
13106  * @tree_view: A #GtkTreeView.
13107  * @reorderable: %TRUE, if the tree can be reordered.
13108  *
13109  * This function is a convenience function to allow you to reorder
13110  * models that support the #GtkTreeDragSourceIface and the
13111  * #GtkTreeDragDestIface.  Both #GtkTreeStore and #GtkListStore support
13112  * these.  If @reorderable is %TRUE, then the user can reorder the
13113  * model by dragging and dropping rows. The developer can listen to
13114  * these changes by connecting to the model's row_inserted and
13115  * row_deleted signals. The reordering is implemented by setting up
13116  * the tree view as a drag source and destination. Therefore, drag and
13117  * drop can not be used in a reorderable view for any other purpose.
13118  *
13119  * This function does not give you any degree of control over the order -- any
13120  * reordering is allowed.  If more control is needed, you should probably
13121  * handle drag and drop manually.
13122  **/
13123 void
13124 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
13125                                gboolean     reorderable)
13126 {
13127   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13128
13129   reorderable = reorderable != FALSE;
13130
13131   if (tree_view->priv->reorderable == reorderable)
13132     return;
13133
13134   if (reorderable)
13135     {
13136       const GtkTargetEntry row_targets[] = {
13137         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
13138       };
13139
13140       gtk_tree_view_enable_model_drag_source (tree_view,
13141                                               GDK_BUTTON1_MASK,
13142                                               row_targets,
13143                                               G_N_ELEMENTS (row_targets),
13144                                               GDK_ACTION_MOVE);
13145       gtk_tree_view_enable_model_drag_dest (tree_view,
13146                                             row_targets,
13147                                             G_N_ELEMENTS (row_targets),
13148                                             GDK_ACTION_MOVE);
13149     }
13150   else
13151     {
13152       gtk_tree_view_unset_rows_drag_source (tree_view);
13153       gtk_tree_view_unset_rows_drag_dest (tree_view);
13154     }
13155
13156   tree_view->priv->reorderable = reorderable;
13157
13158   g_object_notify (G_OBJECT (tree_view), "reorderable");
13159 }
13160
13161 static void
13162 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
13163                                GtkTreePath     *path,
13164                                SetCursorFlags   flags)
13165 {
13166   if (!(flags & CURSOR_INVALID) && tree_view->priv->cursor_node)
13167     {
13168       _gtk_tree_view_accessible_remove_state (tree_view,
13169                                               tree_view->priv->cursor_tree,
13170                                               tree_view->priv->cursor_node,
13171                                               GTK_CELL_RENDERER_FOCUSED);
13172       _gtk_tree_view_queue_draw_node (tree_view,
13173                                       tree_view->priv->cursor_tree,
13174                                       tree_view->priv->cursor_node,
13175                                       NULL);
13176     }
13177
13178   /* One cannot set the cursor on a separator.   Also, if
13179    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
13180    * before finding the tree and node belonging to path.  The
13181    * path maps to a non-existing path and we will silently bail out.
13182    * We unset tree and node to avoid further processing.
13183    */
13184   if (path == NULL ||
13185       row_is_separator (tree_view, NULL, path)
13186       || _gtk_tree_view_find_node (tree_view,
13187                                    path,
13188                                    &tree_view->priv->cursor_tree,
13189                                    &tree_view->priv->cursor_node))
13190     {
13191       tree_view->priv->cursor_tree = NULL;
13192       tree_view->priv->cursor_node = NULL;
13193     }
13194
13195   if (tree_view->priv->cursor_node != NULL)
13196     {
13197       GtkRBTree *new_tree = NULL;
13198       GtkRBNode *new_node = NULL;
13199
13200       if ((flags & CLEAR_AND_SELECT) && !tree_view->priv->modify_selection_pressed)
13201         {
13202           GtkTreeSelectMode mode = 0;
13203
13204           if (tree_view->priv->extend_selection_pressed)
13205             mode |= GTK_TREE_SELECT_MODE_EXTEND;
13206
13207           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
13208                                                     tree_view->priv->cursor_node,
13209                                                     tree_view->priv->cursor_tree,
13210                                                     path,
13211                                                     mode,
13212                                                     FALSE);
13213         }
13214
13215       /* We have to re-find tree and node here again, somebody might have
13216        * cleared the node or the whole tree in the GtkTreeSelection::changed
13217        * callback. If the nodes differ we bail out here.
13218        */
13219       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
13220
13221       if (tree_view->priv->cursor_node != new_node)
13222         return;
13223
13224       if (flags & CLAMP_NODE)
13225         {
13226           gtk_tree_view_clamp_node_visible (tree_view,
13227                                             tree_view->priv->cursor_tree,
13228                                             tree_view->priv->cursor_node);
13229           _gtk_tree_view_queue_draw_node (tree_view,
13230                                           tree_view->priv->cursor_tree,
13231                                           tree_view->priv->cursor_node,
13232                                           NULL);
13233         }
13234
13235       _gtk_tree_view_accessible_add_state (tree_view,
13236                                            tree_view->priv->cursor_tree,
13237                                            tree_view->priv->cursor_node,
13238                                            GTK_CELL_RENDERER_FOCUSED);
13239     }
13240
13241   if (!gtk_widget_in_destruction (GTK_WIDGET (tree_view)))
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   gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0);
14559
14560   gtk_widget_style_get (widget,
14561                         "allow-rules", &allow_rules,
14562                         NULL);
14563
14564   if (allow_rules && tree_view->priv->has_rules)
14565     {
14566       GtkRegionFlags row_flags;
14567
14568       if ((_gtk_rbtree_node_get_index (tree, node) % 2))
14569         row_flags = GTK_REGION_ODD;
14570       else
14571         row_flags = GTK_REGION_EVEN;
14572
14573       gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
14574     }
14575
14576   is_separator = row_is_separator (tree_view, &iter, NULL);
14577
14578   cell_offset = x;
14579
14580   background_area.y = y;
14581   background_area.height = gtk_tree_view_get_row_height (tree_view, node);
14582
14583   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
14584
14585   surface = gdk_window_create_similar_surface (tree_view->priv->bin_window,
14586                                                CAIRO_CONTENT_COLOR,
14587                                                bin_window_width + 2,
14588                                                background_area.height + 2);
14589
14590   cr = cairo_create (surface);
14591
14592   gtk_render_background (context, cr, 0, 0,
14593                          bin_window_width + 2,
14594                          background_area.height + 2);
14595
14596   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
14597
14598   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
14599       list;
14600       list = (rtl ? list->prev : list->next))
14601     {
14602       GtkTreeViewColumn *column = list->data;
14603       GdkRectangle cell_area;
14604       gint vertical_separator;
14605
14606       if (!gtk_tree_view_column_get_visible (column))
14607         continue;
14608
14609       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
14610                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14611                                                node->children?TRUE:FALSE);
14612
14613       background_area.x = cell_offset;
14614       background_area.width = gtk_tree_view_column_get_width (column);
14615
14616       gtk_widget_style_get (widget,
14617                             "vertical-separator", &vertical_separator,
14618                             NULL);
14619
14620       cell_area = background_area;
14621
14622       cell_area.y += vertical_separator / 2;
14623       cell_area.height -= vertical_separator;
14624
14625       if (gtk_tree_view_is_expander_column (tree_view, column))
14626         {
14627           if (!rtl)
14628             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
14629           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
14630
14631           if (gtk_tree_view_draw_expanders (tree_view))
14632             {
14633               int expander_size = gtk_tree_view_get_expander_size (tree_view);
14634               if (!rtl)
14635                 cell_area.x += depth * expander_size;
14636               cell_area.width -= depth * expander_size;
14637             }
14638         }
14639
14640       if (gtk_tree_view_column_cell_is_visible (column))
14641         {
14642           if (is_separator)
14643             {
14644               gtk_style_context_save (context);
14645               gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
14646
14647               gtk_render_line (context, cr,
14648                                cell_area.x,
14649                                cell_area.y + cell_area.height / 2,
14650                                cell_area.x + cell_area.width,
14651                                cell_area.y + cell_area.height / 2);
14652
14653               gtk_style_context_restore (context);
14654             }
14655           else
14656             {
14657               _gtk_tree_view_column_cell_render (column,
14658                                                  cr,
14659                                                  &background_area,
14660                                                  &cell_area,
14661                                                  0, FALSE);
14662             }
14663         }
14664       cell_offset += gtk_tree_view_column_get_width (column);
14665     }
14666
14667   cairo_set_source_rgb (cr, 0, 0, 0);
14668   cairo_rectangle (cr,
14669                    0.5, 0.5,
14670                    bin_window_width + 1,
14671                    background_area.height + 1);
14672   cairo_set_line_width (cr, 1.0);
14673   cairo_stroke (cr);
14674
14675   cairo_destroy (cr);
14676
14677   cairo_surface_set_device_offset (surface, 2, 2);
14678
14679   gtk_style_context_restore (context);
14680
14681   return surface;
14682 }
14683
14684
14685 /**
14686  * gtk_tree_view_set_destroy_count_func:
14687  * @tree_view: A #GtkTreeView
14688  * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
14689  * @data: (allow-none): User data to be passed to @func, or %NULL
14690  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14691  *
14692  * This function should almost never be used.  It is meant for private use by
14693  * ATK for determining the number of visible children that are removed when the
14694  * user collapses a row, or a row is deleted.
14695  *
14696  * Deprecated: 3.4: Accessibility does not need the function anymore.
14697  **/
14698 void
14699 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
14700                                       GtkTreeDestroyCountFunc  func,
14701                                       gpointer                 data,
14702                                       GDestroyNotify           destroy)
14703 {
14704   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14705
14706   if (tree_view->priv->destroy_count_destroy)
14707     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
14708
14709   tree_view->priv->destroy_count_func = func;
14710   tree_view->priv->destroy_count_data = data;
14711   tree_view->priv->destroy_count_destroy = destroy;
14712 }
14713
14714
14715 /*
14716  * Interactive search
14717  */
14718
14719 /**
14720  * gtk_tree_view_set_enable_search:
14721  * @tree_view: A #GtkTreeView
14722  * @enable_search: %TRUE, if the user can search interactively
14723  *
14724  * If @enable_search is set, then the user can type in text to search through
14725  * the tree interactively (this is sometimes called "typeahead find").
14726  *
14727  * Note that even if this is %FALSE, the user can still initiate a search
14728  * using the "start-interactive-search" key binding.
14729  */
14730 void
14731 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
14732                                  gboolean     enable_search)
14733 {
14734   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14735
14736   enable_search = !!enable_search;
14737
14738   if (tree_view->priv->enable_search != enable_search)
14739     {
14740        tree_view->priv->enable_search = enable_search;
14741        g_object_notify (G_OBJECT (tree_view), "enable-search");
14742     }
14743 }
14744
14745 /**
14746  * gtk_tree_view_get_enable_search:
14747  * @tree_view: A #GtkTreeView
14748  *
14749  * Returns whether or not the tree allows to start interactive searching
14750  * by typing in text.
14751  *
14752  * Return value: whether or not to let the user search interactively
14753  */
14754 gboolean
14755 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
14756 {
14757   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14758
14759   return tree_view->priv->enable_search;
14760 }
14761
14762
14763 /**
14764  * gtk_tree_view_get_search_column:
14765  * @tree_view: A #GtkTreeView
14766  *
14767  * Gets the column searched on by the interactive search code.
14768  *
14769  * Return value: the column the interactive search code searches in.
14770  */
14771 gint
14772 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
14773 {
14774   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
14775
14776   return (tree_view->priv->search_column);
14777 }
14778
14779 /**
14780  * gtk_tree_view_set_search_column:
14781  * @tree_view: A #GtkTreeView
14782  * @column: the column of the model to search in, or -1 to disable searching
14783  *
14784  * Sets @column as the column where the interactive search code should
14785  * search in for the current model.
14786  *
14787  * If the search column is set, users can use the "start-interactive-search"
14788  * key binding to bring up search popup. The enable-search property controls
14789  * whether simply typing text will also start an interactive search.
14790  *
14791  * Note that @column refers to a column of the current model. The search
14792  * column is reset to -1 when the model is changed.
14793  */
14794 void
14795 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
14796                                  gint         column)
14797 {
14798   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14799   g_return_if_fail (column >= -1);
14800
14801   if (tree_view->priv->search_column == column)
14802     return;
14803
14804   tree_view->priv->search_column = column;
14805   g_object_notify (G_OBJECT (tree_view), "search-column");
14806 }
14807
14808 /**
14809  * gtk_tree_view_get_search_equal_func: (skip)
14810  * @tree_view: A #GtkTreeView
14811  *
14812  * Returns the compare function currently in use.
14813  *
14814  * Return value: the currently used compare function for the search code.
14815  */
14816
14817 GtkTreeViewSearchEqualFunc
14818 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
14819 {
14820   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14821
14822   return tree_view->priv->search_equal_func;
14823 }
14824
14825 /**
14826  * gtk_tree_view_set_search_equal_func:
14827  * @tree_view: A #GtkTreeView
14828  * @search_equal_func: the compare function to use during the search
14829  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
14830  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
14831  *
14832  * Sets the compare function for the interactive search capabilities; note
14833  * that somewhat like strcmp() returning 0 for equality
14834  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
14835  **/
14836 void
14837 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14838                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14839                                      gpointer                    search_user_data,
14840                                      GDestroyNotify              search_destroy)
14841 {
14842   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14843   g_return_if_fail (search_equal_func != NULL);
14844
14845   if (tree_view->priv->search_destroy)
14846     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14847
14848   tree_view->priv->search_equal_func = search_equal_func;
14849   tree_view->priv->search_user_data = search_user_data;
14850   tree_view->priv->search_destroy = search_destroy;
14851   if (tree_view->priv->search_equal_func == NULL)
14852     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14853 }
14854
14855 /**
14856  * gtk_tree_view_get_search_entry:
14857  * @tree_view: A #GtkTreeView
14858  *
14859  * Returns the #GtkEntry which is currently in use as interactive search
14860  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14861  * will be returned.
14862  *
14863  * Return value: (transfer none): the entry currently in use as search entry.
14864  *
14865  * Since: 2.10
14866  */
14867 GtkEntry *
14868 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14869 {
14870   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14871
14872   if (tree_view->priv->search_custom_entry_set)
14873     return GTK_ENTRY (tree_view->priv->search_entry);
14874
14875   return NULL;
14876 }
14877
14878 /**
14879  * gtk_tree_view_set_search_entry:
14880  * @tree_view: A #GtkTreeView
14881  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
14882  *
14883  * Sets the entry which the interactive search code will use for this
14884  * @tree_view.  This is useful when you want to provide a search entry
14885  * in our interface at all time at a fixed position.  Passing %NULL for
14886  * @entry will make the interactive search code use the built-in popup
14887  * entry again.
14888  *
14889  * Since: 2.10
14890  */
14891 void
14892 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14893                                 GtkEntry    *entry)
14894 {
14895   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14896   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14897
14898   if (tree_view->priv->search_custom_entry_set)
14899     {
14900       if (tree_view->priv->search_entry_changed_id)
14901         {
14902           g_signal_handler_disconnect (tree_view->priv->search_entry,
14903                                        tree_view->priv->search_entry_changed_id);
14904           tree_view->priv->search_entry_changed_id = 0;
14905         }
14906       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14907                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14908                                             tree_view);
14909
14910       g_object_unref (tree_view->priv->search_entry);
14911     }
14912   else if (tree_view->priv->search_window)
14913     {
14914       gtk_widget_destroy (tree_view->priv->search_window);
14915
14916       tree_view->priv->search_window = NULL;
14917     }
14918
14919   if (entry)
14920     {
14921       tree_view->priv->search_entry = g_object_ref (entry);
14922       tree_view->priv->search_custom_entry_set = TRUE;
14923
14924       if (tree_view->priv->search_entry_changed_id == 0)
14925         {
14926           tree_view->priv->search_entry_changed_id =
14927             g_signal_connect (tree_view->priv->search_entry, "changed",
14928                               G_CALLBACK (gtk_tree_view_search_init),
14929                               tree_view);
14930         }
14931
14932         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14933                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14934                           tree_view);
14935
14936         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14937     }
14938   else
14939     {
14940       tree_view->priv->search_entry = NULL;
14941       tree_view->priv->search_custom_entry_set = FALSE;
14942     }
14943 }
14944
14945 /**
14946  * gtk_tree_view_set_search_position_func:
14947  * @tree_view: A #GtkTreeView
14948  * @func: (allow-none): the function to use to position the search dialog, or %NULL
14949  *    to use the default search position function
14950  * @data: (allow-none): user data to pass to @func, or %NULL
14951  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14952  *
14953  * Sets the function to use when positioning the search dialog.
14954  *
14955  * Since: 2.10
14956  **/
14957 void
14958 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
14959                                         GtkTreeViewSearchPositionFunc  func,
14960                                         gpointer                       user_data,
14961                                         GDestroyNotify                 destroy)
14962 {
14963   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14964
14965   if (tree_view->priv->search_position_destroy)
14966     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
14967
14968   tree_view->priv->search_position_func = func;
14969   tree_view->priv->search_position_user_data = user_data;
14970   tree_view->priv->search_position_destroy = destroy;
14971   if (tree_view->priv->search_position_func == NULL)
14972     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
14973 }
14974
14975 /**
14976  * gtk_tree_view_get_search_position_func: (skip)
14977  * @tree_view: A #GtkTreeView
14978  *
14979  * Returns the positioning function currently in use.
14980  *
14981  * Return value: the currently used function for positioning the search dialog.
14982  *
14983  * Since: 2.10
14984  */
14985 GtkTreeViewSearchPositionFunc
14986 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
14987 {
14988   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14989
14990   return tree_view->priv->search_position_func;
14991 }
14992
14993
14994 static void
14995 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
14996                                   GtkTreeView *tree_view,
14997                                   GdkDevice   *device)
14998 {
14999   if (tree_view->priv->disable_popdown)
15000     return;
15001
15002   if (tree_view->priv->search_entry_changed_id)
15003     {
15004       g_signal_handler_disconnect (tree_view->priv->search_entry,
15005                                    tree_view->priv->search_entry_changed_id);
15006       tree_view->priv->search_entry_changed_id = 0;
15007     }
15008   if (tree_view->priv->typeselect_flush_timeout)
15009     {
15010       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15011       tree_view->priv->typeselect_flush_timeout = 0;
15012     }
15013
15014   if (gtk_widget_get_visible (search_dialog))
15015     {
15016       /* send focus-in event */
15017       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
15018       gtk_widget_hide (search_dialog);
15019       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
15020       send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
15021     }
15022 }
15023
15024 static void
15025 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
15026                                     GtkWidget   *search_dialog,
15027                                     gpointer     user_data)
15028 {
15029   gint x, y;
15030   gint tree_x, tree_y;
15031   gint tree_width, tree_height;
15032   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
15033   GdkScreen *screen = gdk_window_get_screen (tree_window);
15034   GtkRequisition requisition;
15035   gint monitor_num;
15036   GdkRectangle monitor;
15037
15038   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
15039   gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
15040
15041   gtk_widget_realize (search_dialog);
15042
15043   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
15044   tree_width = gdk_window_get_width (tree_window);
15045   tree_height = gdk_window_get_height (tree_window);
15046   gtk_widget_get_preferred_size (search_dialog, &requisition, NULL);
15047
15048   if (tree_x + tree_width > gdk_screen_get_width (screen))
15049     x = gdk_screen_get_width (screen) - requisition.width;
15050   else if (tree_x + tree_width - requisition.width < 0)
15051     x = 0;
15052   else
15053     x = tree_x + tree_width - requisition.width;
15054
15055   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
15056     y = gdk_screen_get_height (screen) - requisition.height;
15057   else if (tree_y + tree_height < 0) /* isn't really possible ... */
15058     y = 0;
15059   else
15060     y = tree_y + tree_height;
15061
15062   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
15063 }
15064
15065 static void
15066 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
15067                                       GtkMenu  *menu,
15068                                       gpointer  data)
15069 {
15070   GtkTreeView *tree_view = (GtkTreeView *)data;
15071
15072   tree_view->priv->disable_popdown = 1;
15073   g_signal_connect (menu, "hide",
15074                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
15075 }
15076
15077 /* Because we're visible but offscreen, we just set a flag in the preedit
15078  * callback.
15079  */
15080 static void
15081 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
15082                                       GtkTreeView  *tree_view)
15083 {
15084   tree_view->priv->imcontext_changed = 1;
15085   if (tree_view->priv->typeselect_flush_timeout)
15086     {
15087       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15088       tree_view->priv->typeselect_flush_timeout =
15089         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15090                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15091                        tree_view);
15092     }
15093
15094 }
15095
15096 static void
15097 gtk_tree_view_search_activate (GtkEntry    *entry,
15098                                GtkTreeView *tree_view)
15099 {
15100   GtkTreePath *path;
15101
15102   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
15103                                     tree_view,
15104                                     gtk_get_current_event_device ());
15105
15106   /* If we have a row selected and it's the cursor row, we activate
15107    * the row XXX */
15108   if (tree_view->priv->cursor_node &&
15109       GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
15110     {
15111       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
15112                                              tree_view->priv->cursor_node);
15113
15114       gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
15115
15116       gtk_tree_path_free (path);
15117     }
15118 }
15119
15120 static gboolean
15121 gtk_tree_view_real_search_enable_popdown (gpointer data)
15122 {
15123   GtkTreeView *tree_view = (GtkTreeView *)data;
15124
15125   tree_view->priv->disable_popdown = 0;
15126
15127   return FALSE;
15128 }
15129
15130 static void
15131 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
15132                                      gpointer   data)
15133 {
15134   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
15135 }
15136
15137 static gboolean
15138 gtk_tree_view_search_delete_event (GtkWidget *widget,
15139                                    GdkEventAny *event,
15140                                    GtkTreeView *tree_view)
15141 {
15142   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15143
15144   gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
15145
15146   return TRUE;
15147 }
15148
15149 static gboolean
15150 gtk_tree_view_search_button_press_event (GtkWidget *widget,
15151                                          GdkEventButton *event,
15152                                          GtkTreeView *tree_view)
15153 {
15154   GdkDevice *keyb_device;
15155
15156   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15157
15158   keyb_device = gdk_device_get_associated_device (event->device);
15159   gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
15160
15161   if (event->window == tree_view->priv->bin_window)
15162     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
15163
15164   return TRUE;
15165 }
15166
15167 static gboolean
15168 gtk_tree_view_search_scroll_event (GtkWidget *widget,
15169                                    GdkEventScroll *event,
15170                                    GtkTreeView *tree_view)
15171 {
15172   gboolean retval = FALSE;
15173
15174   if (event->direction == GDK_SCROLL_UP)
15175     {
15176       gtk_tree_view_search_move (widget, tree_view, TRUE);
15177       retval = TRUE;
15178     }
15179   else if (event->direction == GDK_SCROLL_DOWN)
15180     {
15181       gtk_tree_view_search_move (widget, tree_view, FALSE);
15182       retval = TRUE;
15183     }
15184
15185   /* renew the flush timeout */
15186   if (retval && tree_view->priv->typeselect_flush_timeout
15187       && !tree_view->priv->search_custom_entry_set)
15188     {
15189       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15190       tree_view->priv->typeselect_flush_timeout =
15191         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15192                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15193                        tree_view);
15194     }
15195
15196   return retval;
15197 }
15198
15199 static gboolean
15200 gtk_tree_view_search_key_press_event (GtkWidget *widget,
15201                                       GdkEventKey *event,
15202                                       GtkTreeView *tree_view)
15203 {
15204   GdkModifierType default_accel;
15205   gboolean        retval = FALSE;
15206
15207   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15208   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15209
15210   /* close window and cancel the search */
15211   if (!tree_view->priv->search_custom_entry_set
15212       && (event->keyval == GDK_KEY_Escape ||
15213           event->keyval == GDK_KEY_Tab ||
15214             event->keyval == GDK_KEY_KP_Tab ||
15215             event->keyval == GDK_KEY_ISO_Left_Tab))
15216     {
15217       gtk_tree_view_search_dialog_hide (widget, tree_view,
15218                                         gdk_event_get_device ((GdkEvent *) event));
15219       return TRUE;
15220     }
15221
15222   default_accel = gtk_widget_get_modifier_mask (widget,
15223                                                 GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
15224
15225   /* select previous matching iter */
15226   if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
15227     {
15228       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15229         gtk_widget_error_bell (widget);
15230
15231       retval = TRUE;
15232     }
15233
15234   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == (default_accel | GDK_SHIFT_MASK))
15235       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15236     {
15237       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15238         gtk_widget_error_bell (widget);
15239
15240       retval = TRUE;
15241     }
15242
15243   /* select next matching iter */
15244   if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
15245     {
15246       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15247         gtk_widget_error_bell (widget);
15248
15249       retval = TRUE;
15250     }
15251
15252   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == default_accel)
15253       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15254     {
15255       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15256         gtk_widget_error_bell (widget);
15257
15258       retval = TRUE;
15259     }
15260
15261   /* renew the flush timeout */
15262   if (retval && tree_view->priv->typeselect_flush_timeout
15263       && !tree_view->priv->search_custom_entry_set)
15264     {
15265       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15266       tree_view->priv->typeselect_flush_timeout =
15267         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15268                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15269                        tree_view);
15270     }
15271
15272   return retval;
15273 }
15274
15275 /*  this function returns FALSE if there is a search string but
15276  *  nothing was found, and TRUE otherwise.
15277  */
15278 static gboolean
15279 gtk_tree_view_search_move (GtkWidget   *window,
15280                            GtkTreeView *tree_view,
15281                            gboolean     up)
15282 {
15283   gboolean ret;
15284   gint len;
15285   gint count = 0;
15286   const gchar *text;
15287   GtkTreeIter iter;
15288   GtkTreeModel *model;
15289   GtkTreeSelection *selection;
15290
15291   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
15292
15293   g_return_val_if_fail (text != NULL, FALSE);
15294
15295   len = strlen (text);
15296
15297   if (up && tree_view->priv->selected_iter == 1)
15298     return strlen (text) < 1;
15299
15300   len = strlen (text);
15301
15302   if (len < 1)
15303     return TRUE;
15304
15305   model = gtk_tree_view_get_model (tree_view);
15306   selection = gtk_tree_view_get_selection (tree_view);
15307
15308   /* search */
15309   gtk_tree_selection_unselect_all (selection);
15310   if (!gtk_tree_model_get_iter_first (model, &iter))
15311     return TRUE;
15312
15313   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
15314                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
15315
15316   if (ret)
15317     {
15318       /* found */
15319       tree_view->priv->selected_iter += up?(-1):(1);
15320       return TRUE;
15321     }
15322   else
15323     {
15324       /* return to old iter */
15325       count = 0;
15326       gtk_tree_model_get_iter_first (model, &iter);
15327       gtk_tree_view_search_iter (model, selection,
15328                                  &iter, text,
15329                                  &count, tree_view->priv->selected_iter);
15330       return FALSE;
15331     }
15332 }
15333
15334 static gboolean
15335 gtk_tree_view_search_equal_func (GtkTreeModel *model,
15336                                  gint          column,
15337                                  const gchar  *key,
15338                                  GtkTreeIter  *iter,
15339                                  gpointer      search_data)
15340 {
15341   gboolean retval = TRUE;
15342   const gchar *str;
15343   gchar *normalized_string;
15344   gchar *normalized_key;
15345   gchar *case_normalized_string = NULL;
15346   gchar *case_normalized_key = NULL;
15347   GValue value = G_VALUE_INIT;
15348   GValue transformed = G_VALUE_INIT;
15349
15350   gtk_tree_model_get_value (model, iter, column, &value);
15351
15352   g_value_init (&transformed, G_TYPE_STRING);
15353
15354   if (!g_value_transform (&value, &transformed))
15355     {
15356       g_value_unset (&value);
15357       return TRUE;
15358     }
15359
15360   g_value_unset (&value);
15361
15362   str = g_value_get_string (&transformed);
15363   if (!str)
15364     {
15365       g_value_unset (&transformed);
15366       return TRUE;
15367     }
15368
15369   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
15370   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
15371
15372   if (normalized_string && normalized_key)
15373     {
15374       case_normalized_string = g_utf8_casefold (normalized_string, -1);
15375       case_normalized_key = g_utf8_casefold (normalized_key, -1);
15376
15377       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
15378         retval = FALSE;
15379     }
15380
15381   g_value_unset (&transformed);
15382   g_free (normalized_key);
15383   g_free (normalized_string);
15384   g_free (case_normalized_key);
15385   g_free (case_normalized_string);
15386
15387   return retval;
15388 }
15389
15390 static gboolean
15391 gtk_tree_view_search_iter (GtkTreeModel     *model,
15392                            GtkTreeSelection *selection,
15393                            GtkTreeIter      *iter,
15394                            const gchar      *text,
15395                            gint             *count,
15396                            gint              n)
15397 {
15398   GtkRBTree *tree = NULL;
15399   GtkRBNode *node = NULL;
15400   GtkTreePath *path;
15401
15402   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
15403
15404   path = gtk_tree_model_get_path (model, iter);
15405   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15406
15407   do
15408     {
15409       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
15410         {
15411           (*count)++;
15412           if (*count == n)
15413             {
15414               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
15415                                             TRUE, 0.5, 0.0);
15416               gtk_tree_selection_select_iter (selection, iter);
15417               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15418
15419               if (path)
15420                 gtk_tree_path_free (path);
15421
15422               return TRUE;
15423             }
15424         }
15425
15426       if (node->children)
15427         {
15428           gboolean has_child;
15429           GtkTreeIter tmp;
15430
15431           tree = node->children;
15432           node = _gtk_rbtree_first (tree);
15433
15434           tmp = *iter;
15435           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
15436           gtk_tree_path_down (path);
15437
15438           /* sanity check */
15439           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
15440         }
15441       else
15442         {
15443           gboolean done = FALSE;
15444
15445           do
15446             {
15447               node = _gtk_rbtree_next (tree, node);
15448
15449               if (node)
15450                 {
15451                   gboolean has_next;
15452
15453                   has_next = gtk_tree_model_iter_next (model, iter);
15454
15455                   done = TRUE;
15456                   gtk_tree_path_next (path);
15457
15458                   /* sanity check */
15459                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
15460                 }
15461               else
15462                 {
15463                   gboolean has_parent;
15464                   GtkTreeIter tmp_iter = *iter;
15465
15466                   node = tree->parent_node;
15467                   tree = tree->parent_tree;
15468
15469                   if (!tree)
15470                     {
15471                       if (path)
15472                         gtk_tree_path_free (path);
15473
15474                       /* we've run out of tree, done with this func */
15475                       return FALSE;
15476                     }
15477
15478                   has_parent = gtk_tree_model_iter_parent (model,
15479                                                            iter,
15480                                                            &tmp_iter);
15481                   gtk_tree_path_up (path);
15482
15483                   /* sanity check */
15484                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
15485                 }
15486             }
15487           while (!done);
15488         }
15489     }
15490   while (1);
15491
15492   return FALSE;
15493 }
15494
15495 static void
15496 gtk_tree_view_search_init (GtkWidget   *entry,
15497                            GtkTreeView *tree_view)
15498 {
15499   gint ret;
15500   gint count = 0;
15501   const gchar *text;
15502   GtkTreeIter iter;
15503   GtkTreeModel *model;
15504   GtkTreeSelection *selection;
15505
15506   g_return_if_fail (GTK_IS_ENTRY (entry));
15507   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15508
15509   text = gtk_entry_get_text (GTK_ENTRY (entry));
15510
15511   model = gtk_tree_view_get_model (tree_view);
15512   selection = gtk_tree_view_get_selection (tree_view);
15513
15514   /* search */
15515   gtk_tree_selection_unselect_all (selection);
15516   if (tree_view->priv->typeselect_flush_timeout
15517       && !tree_view->priv->search_custom_entry_set)
15518     {
15519       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15520       tree_view->priv->typeselect_flush_timeout =
15521         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15522                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15523                        tree_view);
15524     }
15525
15526   if (*text == '\0')
15527     return;
15528
15529   if (!gtk_tree_model_get_iter_first (model, &iter))
15530     return;
15531
15532   ret = gtk_tree_view_search_iter (model, selection,
15533                                    &iter, text,
15534                                    &count, 1);
15535
15536   if (ret)
15537     tree_view->priv->selected_iter = 1;
15538 }
15539
15540 void
15541 _gtk_tree_view_remove_editable (GtkTreeView       *tree_view,
15542                                 GtkTreeViewColumn *column,
15543                                 GtkCellEditable   *cell_editable)
15544 {
15545   if (tree_view->priv->edited_column == NULL)
15546     return;
15547
15548   g_return_if_fail (column == tree_view->priv->edited_column);
15549
15550   tree_view->priv->edited_column = NULL;
15551
15552   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
15553     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
15554
15555   gtk_container_remove (GTK_CONTAINER (tree_view),
15556                         GTK_WIDGET (cell_editable));
15557
15558   /* FIXME should only redraw a single node */
15559   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15560 }
15561
15562 static gboolean
15563 gtk_tree_view_start_editing (GtkTreeView *tree_view,
15564                              GtkTreePath *cursor_path,
15565                              gboolean     edit_only)
15566 {
15567   GtkTreeIter iter;
15568   GdkRectangle cell_area;
15569   GtkTreeViewColumn *focus_column;
15570   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
15571   gint retval = FALSE;
15572   GtkRBTree *cursor_tree;
15573   GtkRBNode *cursor_node;
15574
15575   g_assert (tree_view->priv->focus_column);
15576   focus_column = tree_view->priv->focus_column;
15577
15578   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
15579     return FALSE;
15580
15581   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
15582       cursor_node == NULL)
15583     return FALSE;
15584
15585   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
15586
15587   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
15588
15589   gtk_tree_view_column_cell_set_cell_data (focus_column,
15590                                            tree_view->priv->model,
15591                                            &iter,
15592                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
15593                                            cursor_node->children ? TRUE : FALSE);
15594   gtk_tree_view_get_cell_area (tree_view,
15595                                cursor_path,
15596                                focus_column,
15597                                &cell_area);
15598
15599   if (gtk_cell_area_activate (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (focus_column)),
15600                               _gtk_tree_view_column_get_context (focus_column),
15601                               GTK_WIDGET (tree_view),
15602                               &cell_area,
15603                               flags, edit_only))
15604     retval = TRUE;
15605
15606   return retval;
15607 }
15608
15609 void
15610 _gtk_tree_view_add_editable (GtkTreeView       *tree_view,
15611                              GtkTreeViewColumn *column,
15612                              GtkTreePath       *path,
15613                              GtkCellEditable   *cell_editable,
15614                              GdkRectangle      *cell_area)
15615 {
15616   gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
15617   GtkRequisition requisition;
15618
15619   tree_view->priv->edited_column = column;
15620
15621   gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15622   cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
15623
15624   gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
15625                                  &requisition, NULL);
15626
15627   tree_view->priv->draw_keyfocus = TRUE;
15628
15629   if (requisition.height < cell_area->height)
15630     {
15631       gint diff = cell_area->height - requisition.height;
15632       gtk_tree_view_put (tree_view,
15633                          GTK_WIDGET (cell_editable),
15634                          cell_area->x, cell_area->y + diff/2,
15635                          cell_area->width, requisition.height);
15636     }
15637   else
15638     {
15639       gtk_tree_view_put (tree_view,
15640                          GTK_WIDGET (cell_editable),
15641                          cell_area->x, cell_area->y,
15642                          cell_area->width, cell_area->height);
15643     }
15644 }
15645
15646 static void
15647 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
15648                             gboolean     cancel_editing)
15649 {
15650   GtkTreeViewColumn *column;
15651
15652   if (tree_view->priv->edited_column == NULL)
15653     return;
15654
15655   /*
15656    * This is very evil. We need to do this, because
15657    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
15658    * later on. If gtk_tree_view_row_changed notices
15659    * tree_view->priv->edited_column != NULL, it'll call
15660    * gtk_tree_view_stop_editing again. Bad things will happen then.
15661    *
15662    * Please read that again if you intend to modify anything here.
15663    */
15664
15665   column = tree_view->priv->edited_column;
15666   gtk_cell_area_stop_editing (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)), cancel_editing);
15667   tree_view->priv->edited_column = NULL;
15668 }
15669
15670
15671 /**
15672  * gtk_tree_view_set_hover_selection:
15673  * @tree_view: a #GtkTreeView
15674  * @hover: %TRUE to enable hover selection mode
15675  *
15676  * Enables or disables the hover selection mode of @tree_view.
15677  * Hover selection makes the selected row follow the pointer.
15678  * Currently, this works only for the selection modes
15679  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
15680  *
15681  * Since: 2.6
15682  **/
15683 void
15684 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
15685                                    gboolean     hover)
15686 {
15687   hover = hover != FALSE;
15688
15689   if (hover != tree_view->priv->hover_selection)
15690     {
15691       tree_view->priv->hover_selection = hover;
15692
15693       g_object_notify (G_OBJECT (tree_view), "hover-selection");
15694     }
15695 }
15696
15697 /**
15698  * gtk_tree_view_get_hover_selection:
15699  * @tree_view: a #GtkTreeView
15700  *
15701  * Returns whether hover selection mode is turned on for @tree_view.
15702  *
15703  * Return value: %TRUE if @tree_view is in hover selection mode
15704  *
15705  * Since: 2.6
15706  **/
15707 gboolean
15708 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
15709 {
15710   return tree_view->priv->hover_selection;
15711 }
15712
15713 /**
15714  * gtk_tree_view_set_hover_expand:
15715  * @tree_view: a #GtkTreeView
15716  * @expand: %TRUE to enable hover selection mode
15717  *
15718  * Enables or disables the hover expansion mode of @tree_view.
15719  * Hover expansion makes rows expand or collapse if the pointer
15720  * moves over them.
15721  *
15722  * Since: 2.6
15723  **/
15724 void
15725 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
15726                                 gboolean     expand)
15727 {
15728   expand = expand != FALSE;
15729
15730   if (expand != tree_view->priv->hover_expand)
15731     {
15732       tree_view->priv->hover_expand = expand;
15733
15734       g_object_notify (G_OBJECT (tree_view), "hover-expand");
15735     }
15736 }
15737
15738 /**
15739  * gtk_tree_view_get_hover_expand:
15740  * @tree_view: a #GtkTreeView
15741  *
15742  * Returns whether hover expansion mode is turned on for @tree_view.
15743  *
15744  * Return value: %TRUE if @tree_view is in hover expansion mode
15745  *
15746  * Since: 2.6
15747  **/
15748 gboolean
15749 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
15750 {
15751   return tree_view->priv->hover_expand;
15752 }
15753
15754 /**
15755  * gtk_tree_view_set_rubber_banding:
15756  * @tree_view: a #GtkTreeView
15757  * @enable: %TRUE to enable rubber banding
15758  *
15759  * Enables or disables rubber banding in @tree_view.  If the selection mode
15760  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
15761  * multiple rows by dragging the mouse.
15762  *
15763  * Since: 2.10
15764  **/
15765 void
15766 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
15767                                   gboolean     enable)
15768 {
15769   enable = enable != FALSE;
15770
15771   if (enable != tree_view->priv->rubber_banding_enable)
15772     {
15773       tree_view->priv->rubber_banding_enable = enable;
15774
15775       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
15776     }
15777 }
15778
15779 /**
15780  * gtk_tree_view_get_rubber_banding:
15781  * @tree_view: a #GtkTreeView
15782  *
15783  * Returns whether rubber banding is turned on for @tree_view.  If the
15784  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15785  * user to select multiple rows by dragging the mouse.
15786  *
15787  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15788  *
15789  * Since: 2.10
15790  **/
15791 gboolean
15792 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15793 {
15794   return tree_view->priv->rubber_banding_enable;
15795 }
15796
15797 /**
15798  * gtk_tree_view_is_rubber_banding_active:
15799  * @tree_view: a #GtkTreeView
15800  *
15801  * Returns whether a rubber banding operation is currently being done
15802  * in @tree_view.
15803  *
15804  * Return value: %TRUE if a rubber banding operation is currently being
15805  * done in @tree_view.
15806  *
15807  * Since: 2.12
15808  **/
15809 gboolean
15810 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15811 {
15812   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15813
15814   if (tree_view->priv->rubber_banding_enable
15815       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15816     return TRUE;
15817
15818   return FALSE;
15819 }
15820
15821 /**
15822  * gtk_tree_view_get_row_separator_func: (skip)
15823  * @tree_view: a #GtkTreeView
15824  *
15825  * Returns the current row separator function.
15826  *
15827  * Return value: the current row separator function.
15828  *
15829  * Since: 2.6
15830  **/
15831 GtkTreeViewRowSeparatorFunc
15832 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15833 {
15834   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15835
15836   return tree_view->priv->row_separator_func;
15837 }
15838
15839 /**
15840  * gtk_tree_view_set_row_separator_func:
15841  * @tree_view: a #GtkTreeView
15842  * @func: (allow-none): a #GtkTreeViewRowSeparatorFunc
15843  * @data: (allow-none): user data to pass to @func, or %NULL
15844  * @destroy: (allow-none): destroy notifier for @data, or %NULL
15845  *
15846  * Sets the row separator function, which is used to determine
15847  * whether a row should be drawn as a separator. If the row separator
15848  * function is %NULL, no separators are drawn. This is the default value.
15849  *
15850  * Since: 2.6
15851  **/
15852 void
15853 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15854                                       GtkTreeViewRowSeparatorFunc  func,
15855                                       gpointer                     data,
15856                                       GDestroyNotify               destroy)
15857 {
15858   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15859
15860   if (tree_view->priv->row_separator_destroy)
15861     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15862
15863   tree_view->priv->row_separator_func = func;
15864   tree_view->priv->row_separator_data = data;
15865   tree_view->priv->row_separator_destroy = destroy;
15866
15867   /* Have the tree recalculate heights */
15868   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15869   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15870 }
15871
15872
15873 static void
15874 gtk_tree_view_grab_notify (GtkWidget *widget,
15875                            gboolean   was_grabbed)
15876 {
15877   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15878
15879   tree_view->priv->in_grab = !was_grabbed;
15880
15881   if (!was_grabbed)
15882     {
15883       tree_view->priv->pressed_button = -1;
15884
15885       if (tree_view->priv->rubber_band_status)
15886         gtk_tree_view_stop_rubber_band (tree_view);
15887     }
15888 }
15889
15890 static void
15891 gtk_tree_view_state_flags_changed (GtkWidget     *widget,
15892                                    GtkStateFlags  previous_state)
15893 {
15894   if (gtk_widget_get_realized (widget))
15895     gtk_tree_view_ensure_background (GTK_TREE_VIEW (widget));
15896
15897   gtk_widget_queue_draw (widget);
15898 }
15899
15900 /**
15901  * gtk_tree_view_get_grid_lines:
15902  * @tree_view: a #GtkTreeView
15903  *
15904  * Returns which grid lines are enabled in @tree_view.
15905  *
15906  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15907  * are enabled.
15908  *
15909  * Since: 2.10
15910  */
15911 GtkTreeViewGridLines
15912 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15913 {
15914   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15915
15916   return tree_view->priv->grid_lines;
15917 }
15918
15919 /**
15920  * gtk_tree_view_set_grid_lines:
15921  * @tree_view: a #GtkTreeView
15922  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15923  * enable.
15924  *
15925  * Sets which grid lines to draw in @tree_view.
15926  *
15927  * Since: 2.10
15928  */
15929 void
15930 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15931                               GtkTreeViewGridLines   grid_lines)
15932 {
15933   GtkTreeViewPrivate *priv;
15934   GtkWidget *widget;
15935   GtkTreeViewGridLines old_grid_lines;
15936
15937   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15938
15939   priv = tree_view->priv;
15940   widget = GTK_WIDGET (tree_view);
15941
15942   old_grid_lines = priv->grid_lines;
15943   priv->grid_lines = grid_lines;
15944
15945   if (gtk_widget_get_realized (widget))
15946     {
15947       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15948           priv->grid_line_width)
15949         {
15950           priv->grid_line_width = 0;
15951         }
15952
15953       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15954           !priv->grid_line_width)
15955         {
15956           gint8 *dash_list;
15957
15958           gtk_widget_style_get (widget,
15959                                 "grid-line-width", &priv->grid_line_width,
15960                                 "grid-line-pattern", (gchar *)&dash_list,
15961                                 NULL);
15962
15963           if (dash_list)
15964             {
15965               priv->grid_line_dashes[0] = dash_list[0];
15966               if (dash_list[0])
15967                 priv->grid_line_dashes[1] = dash_list[1];
15968
15969               g_free (dash_list);
15970             }
15971           else
15972             {
15973               priv->grid_line_dashes[0] = 1;
15974               priv->grid_line_dashes[1] = 1;
15975             }
15976         }
15977     }
15978
15979   if (old_grid_lines != grid_lines)
15980     {
15981       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15982
15983       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
15984     }
15985 }
15986
15987 /**
15988  * gtk_tree_view_get_enable_tree_lines:
15989  * @tree_view: a #GtkTreeView.
15990  *
15991  * Returns whether or not tree lines are drawn in @tree_view.
15992  *
15993  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
15994  * otherwise.
15995  *
15996  * Since: 2.10
15997  */
15998 gboolean
15999 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
16000 {
16001   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16002
16003   return tree_view->priv->tree_lines_enabled;
16004 }
16005
16006 /**
16007  * gtk_tree_view_set_enable_tree_lines:
16008  * @tree_view: a #GtkTreeView
16009  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
16010  *
16011  * Sets whether to draw lines interconnecting the expanders in @tree_view.
16012  * This does not have any visible effects for lists.
16013  *
16014  * Since: 2.10
16015  */
16016 void
16017 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
16018                                      gboolean     enabled)
16019 {
16020   GtkTreeViewPrivate *priv;
16021   GtkWidget *widget;
16022   gboolean was_enabled;
16023
16024   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16025
16026   enabled = enabled != FALSE;
16027
16028   priv = tree_view->priv;
16029   widget = GTK_WIDGET (tree_view);
16030
16031   was_enabled = priv->tree_lines_enabled;
16032
16033   priv->tree_lines_enabled = enabled;
16034
16035   if (gtk_widget_get_realized (widget))
16036     {
16037       if (!enabled && priv->tree_line_width)
16038         {
16039           priv->tree_line_width = 0;
16040         }
16041
16042       if (enabled && !priv->tree_line_width)
16043         {
16044           gint8 *dash_list;
16045           gtk_widget_style_get (widget,
16046                                 "tree-line-width", &priv->tree_line_width,
16047                                 "tree-line-pattern", (gchar *)&dash_list,
16048                                 NULL);
16049
16050           if (dash_list)
16051             {
16052               priv->tree_line_dashes[0] = dash_list[0];
16053               if (dash_list[0])
16054                 priv->tree_line_dashes[1] = dash_list[1];
16055
16056               g_free (dash_list);
16057             }
16058           else
16059             {
16060               priv->tree_line_dashes[0] = 1;
16061               priv->tree_line_dashes[1] = 1;
16062             }
16063         }
16064     }
16065
16066   if (was_enabled != enabled)
16067     {
16068       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16069
16070       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
16071     }
16072 }
16073
16074
16075 /**
16076  * gtk_tree_view_set_show_expanders:
16077  * @tree_view: a #GtkTreeView
16078  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
16079  *
16080  * Sets whether to draw and enable expanders and indent child rows in
16081  * @tree_view.  When disabled there will be no expanders visible in trees
16082  * and there will be no way to expand and collapse rows by default.  Also
16083  * note that hiding the expanders will disable the default indentation.  You
16084  * can set a custom indentation in this case using
16085  * gtk_tree_view_set_level_indentation().
16086  * This does not have any visible effects for lists.
16087  *
16088  * Since: 2.12
16089  */
16090 void
16091 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
16092                                   gboolean     enabled)
16093 {
16094   gboolean was_enabled;
16095
16096   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16097
16098   enabled = enabled != FALSE;
16099   was_enabled = tree_view->priv->show_expanders;
16100
16101   tree_view->priv->show_expanders = enabled == TRUE;
16102
16103   if (enabled != was_enabled)
16104     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16105 }
16106
16107 /**
16108  * gtk_tree_view_get_show_expanders:
16109  * @tree_view: a #GtkTreeView.
16110  *
16111  * Returns whether or not expanders are drawn in @tree_view.
16112  *
16113  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
16114  * otherwise.
16115  *
16116  * Since: 2.12
16117  */
16118 gboolean
16119 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
16120 {
16121   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16122
16123   return tree_view->priv->show_expanders;
16124 }
16125
16126 /**
16127  * gtk_tree_view_set_level_indentation:
16128  * @tree_view: a #GtkTreeView
16129  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
16130  *
16131  * Sets the amount of extra indentation for child levels to use in @tree_view
16132  * in addition to the default indentation.  The value should be specified in
16133  * pixels, a value of 0 disables this feature and in this case only the default
16134  * indentation will be used.
16135  * This does not have any visible effects for lists.
16136  *
16137  * Since: 2.12
16138  */
16139 void
16140 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
16141                                      gint         indentation)
16142 {
16143   tree_view->priv->level_indentation = indentation;
16144
16145   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16146 }
16147
16148 /**
16149  * gtk_tree_view_get_level_indentation:
16150  * @tree_view: a #GtkTreeView.
16151  *
16152  * Returns the amount, in pixels, of extra indentation for child levels
16153  * in @tree_view.
16154  *
16155  * Return value: the amount of extra indentation for child levels in
16156  * @tree_view.  A return value of 0 means that this feature is disabled.
16157  *
16158  * Since: 2.12
16159  */
16160 gint
16161 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
16162 {
16163   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16164
16165   return tree_view->priv->level_indentation;
16166 }
16167
16168 /**
16169  * gtk_tree_view_set_tooltip_row:
16170  * @tree_view: a #GtkTreeView
16171  * @tooltip: a #GtkTooltip
16172  * @path: a #GtkTreePath
16173  *
16174  * Sets the tip area of @tooltip to be the area covered by the row at @path.
16175  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16176  * See also gtk_tooltip_set_tip_area().
16177  *
16178  * Since: 2.12
16179  */
16180 void
16181 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
16182                                GtkTooltip  *tooltip,
16183                                GtkTreePath *path)
16184 {
16185   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16186   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16187
16188   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
16189 }
16190
16191 /**
16192  * gtk_tree_view_set_tooltip_cell:
16193  * @tree_view: a #GtkTreeView
16194  * @tooltip: a #GtkTooltip
16195  * @path: (allow-none): a #GtkTreePath or %NULL
16196  * @column: (allow-none): a #GtkTreeViewColumn or %NULL
16197  * @cell: (allow-none): a #GtkCellRenderer or %NULL
16198  *
16199  * Sets the tip area of @tooltip to the area @path, @column and @cell have
16200  * in common.  For example if @path is %NULL and @column is set, the tip
16201  * area will be set to the full area covered by @column.  See also
16202  * gtk_tooltip_set_tip_area().
16203  *
16204  * Note that if @path is not specified and @cell is set and part of a column
16205  * containing the expander, the tooltip might not show and hide at the correct
16206  * position.  In such cases @path must be set to the current node under the
16207  * mouse cursor for this function to operate correctly.
16208  *
16209  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16210  *
16211  * Since: 2.12
16212  */
16213 void
16214 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
16215                                 GtkTooltip        *tooltip,
16216                                 GtkTreePath       *path,
16217                                 GtkTreeViewColumn *column,
16218                                 GtkCellRenderer   *cell)
16219 {
16220   GtkAllocation allocation;
16221   GdkRectangle rect;
16222
16223   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16224   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16225   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
16226   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
16227
16228   /* Determine x values. */
16229   if (column && cell)
16230     {
16231       GdkRectangle tmp;
16232       gint start, width;
16233
16234       /* We always pass in path here, whether it is NULL or not.
16235        * For cells in expander columns path must be specified so that
16236        * we can correctly account for the indentation.  This also means
16237        * that the tooltip is constrained vertically by the "Determine y
16238        * values" code below; this is not a real problem since cells actually
16239        * don't stretch vertically in constrast to columns.
16240        */
16241       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
16242       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
16243
16244       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16245                                                          tmp.x + start, 0,
16246                                                          &rect.x, NULL);
16247       rect.width = width;
16248     }
16249   else if (column)
16250     {
16251       GdkRectangle tmp;
16252
16253       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
16254       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16255                                                          tmp.x, 0,
16256                                                          &rect.x, NULL);
16257       rect.width = tmp.width;
16258     }
16259   else
16260     {
16261       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
16262       rect.x = 0;
16263       rect.width = allocation.width;
16264     }
16265
16266   /* Determine y values. */
16267   if (path)
16268     {
16269       GdkRectangle tmp;
16270
16271       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
16272       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16273                                                          0, tmp.y,
16274                                                          NULL, &rect.y);
16275       rect.height = tmp.height;
16276     }
16277   else
16278     {
16279       rect.y = 0;
16280       rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
16281     }
16282
16283   gtk_tooltip_set_tip_area (tooltip, &rect);
16284 }
16285
16286 /**
16287  * gtk_tree_view_get_tooltip_context:
16288  * @tree_view: a #GtkTreeView
16289  * @x: (inout): the x coordinate (relative to widget coordinates)
16290  * @y: (inout): the y coordinate (relative to widget coordinates)
16291  * @keyboard_tip: whether this is a keyboard tooltip or not
16292  * @model: (out) (allow-none) (transfer none): a pointer to receive a
16293  *         #GtkTreeModel or %NULL
16294  * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
16295  * @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
16296  *
16297  * This function is supposed to be used in a #GtkWidget::query-tooltip
16298  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
16299  * which are received in the signal handler, should be passed to this
16300  * function without modification.
16301  *
16302  * The return value indicates whether there is a tree view row at the given
16303  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
16304  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
16305  * @model, @path and @iter which have been provided will be set to point to
16306  * that row and the corresponding model.  @x and @y will always be converted
16307  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
16308  *
16309  * Return value: whether or not the given tooltip context points to a row.
16310  *
16311  * Since: 2.12
16312  */
16313 gboolean
16314 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
16315                                    gint          *x,
16316                                    gint          *y,
16317                                    gboolean       keyboard_tip,
16318                                    GtkTreeModel **model,
16319                                    GtkTreePath  **path,
16320                                    GtkTreeIter   *iter)
16321 {
16322   GtkTreePath *tmppath = NULL;
16323
16324   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16325   g_return_val_if_fail (x != NULL, FALSE);
16326   g_return_val_if_fail (y != NULL, FALSE);
16327
16328   if (keyboard_tip)
16329     {
16330       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
16331
16332       if (!tmppath)
16333         return FALSE;
16334     }
16335   else
16336     {
16337       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
16338                                                          x, y);
16339
16340       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
16341                                           &tmppath, NULL, NULL, NULL))
16342         return FALSE;
16343     }
16344
16345   if (model)
16346     *model = gtk_tree_view_get_model (tree_view);
16347
16348   if (iter)
16349     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
16350                              iter, tmppath);
16351
16352   if (path)
16353     *path = tmppath;
16354   else
16355     gtk_tree_path_free (tmppath);
16356
16357   return TRUE;
16358 }
16359
16360 static gboolean
16361 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
16362                                     gint        x,
16363                                     gint        y,
16364                                     gboolean    keyboard_tip,
16365                                     GtkTooltip *tooltip,
16366                                     gpointer    data)
16367 {
16368   GValue value = G_VALUE_INIT;
16369   GValue transformed = G_VALUE_INIT;
16370   GtkTreeIter iter;
16371   GtkTreePath *path;
16372   GtkTreeModel *model;
16373   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
16374
16375   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
16376                                           &x, &y,
16377                                           keyboard_tip,
16378                                           &model, &path, &iter))
16379     return FALSE;
16380
16381   gtk_tree_model_get_value (model, &iter,
16382                             tree_view->priv->tooltip_column, &value);
16383
16384   g_value_init (&transformed, G_TYPE_STRING);
16385
16386   if (!g_value_transform (&value, &transformed))
16387     {
16388       g_value_unset (&value);
16389       gtk_tree_path_free (path);
16390
16391       return FALSE;
16392     }
16393
16394   g_value_unset (&value);
16395
16396   if (!g_value_get_string (&transformed))
16397     {
16398       g_value_unset (&transformed);
16399       gtk_tree_path_free (path);
16400
16401       return FALSE;
16402     }
16403
16404   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
16405   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
16406
16407   gtk_tree_path_free (path);
16408   g_value_unset (&transformed);
16409
16410   return TRUE;
16411 }
16412
16413 /**
16414  * gtk_tree_view_set_tooltip_column:
16415  * @tree_view: a #GtkTreeView
16416  * @column: an integer, which is a valid column number for @tree_view's model
16417  *
16418  * If you only plan to have simple (text-only) tooltips on full rows, you
16419  * can use this function to have #GtkTreeView handle these automatically
16420  * for you. @column should be set to the column in @tree_view's model
16421  * containing the tooltip texts, or -1 to disable this feature.
16422  *
16423  * When enabled, #GtkWidget:has-tooltip will be set to %TRUE and
16424  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
16425  *
16426  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
16427  * so &amp;, &lt;, etc have to be escaped in the text.
16428  *
16429  * Since: 2.12
16430  */
16431 void
16432 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
16433                                   gint         column)
16434 {
16435   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16436
16437   if (column == tree_view->priv->tooltip_column)
16438     return;
16439
16440   if (column == -1)
16441     {
16442       g_signal_handlers_disconnect_by_func (tree_view,
16443                                             gtk_tree_view_set_tooltip_query_cb,
16444                                             NULL);
16445       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
16446     }
16447   else
16448     {
16449       if (tree_view->priv->tooltip_column == -1)
16450         {
16451           g_signal_connect (tree_view, "query-tooltip",
16452                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
16453           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
16454         }
16455     }
16456
16457   tree_view->priv->tooltip_column = column;
16458   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
16459 }
16460
16461 /**
16462  * gtk_tree_view_get_tooltip_column:
16463  * @tree_view: a #GtkTreeView
16464  *
16465  * Returns the column of @tree_view's model which is being used for
16466  * displaying tooltips on @tree_view's rows.
16467  *
16468  * Return value: the index of the tooltip column that is currently being
16469  * used, or -1 if this is disabled.
16470  *
16471  * Since: 2.12
16472  */
16473 gint
16474 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
16475 {
16476   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16477
16478   return tree_view->priv->tooltip_column;
16479 }