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
2868   gtk_widget_style_get (GTK_WIDGET (tree_view),
2869                         "expander-size", &expander_size,
2870                         NULL);
2871
2872   return expander_size;
2873 }
2874
2875 static gboolean
2876 gtk_tree_view_button_press (GtkWidget      *widget,
2877                             GdkEventButton *event)
2878 {
2879   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2880   GList *list;
2881   GtkTreeViewColumn *column = NULL;
2882   gint i;
2883   GdkRectangle background_area;
2884   GdkRectangle cell_area;
2885   gint vertical_separator;
2886   gint horizontal_separator;
2887   gboolean path_is_selectable;
2888   gboolean rtl;
2889
2890   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2891   gtk_tree_view_stop_editing (tree_view, FALSE);
2892   gtk_widget_style_get (widget,
2893                         "vertical-separator", &vertical_separator,
2894                         "horizontal-separator", &horizontal_separator,
2895                         NULL);
2896
2897   /* Don't handle extra mouse buttons events, let them bubble up */
2898   if (event->button > 5)
2899     return FALSE;
2900
2901   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2902    * we're done handling the button press.
2903    */
2904
2905   if (event->window == tree_view->priv->bin_window)
2906     {
2907       GtkRBNode *node;
2908       GtkRBTree *tree;
2909       GtkTreePath *path;
2910       gint depth;
2911       gint new_y;
2912       gint y_offset;
2913       gint dval;
2914       gint pre_val, aft_val;
2915       GtkTreeViewColumn *column = NULL;
2916       gint column_handled_click = FALSE;
2917       gboolean row_double_click = FALSE;
2918       gboolean rtl;
2919       gboolean node_selected;
2920       GdkModifierType extend_mod_mask;
2921       GdkModifierType modify_mod_mask;
2922
2923       /* Empty tree? */
2924       if (tree_view->priv->tree == NULL)
2925         {
2926           grab_focus_and_unset_draw_keyfocus (tree_view);
2927           return TRUE;
2928         }
2929
2930       /* are we in an arrow? */
2931       if (tree_view->priv->prelight_node &&
2932           tree_view->priv->arrow_prelit &&
2933           gtk_tree_view_draw_expanders (tree_view))
2934         {
2935           if (event->button == GDK_BUTTON_PRIMARY)
2936             {
2937               gtk_grab_add (widget);
2938               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2939               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2940               gtk_tree_view_queue_draw_arrow (GTK_TREE_VIEW (widget),
2941                                               tree_view->priv->prelight_tree,
2942                                               tree_view->priv->prelight_node);
2943             }
2944
2945           grab_focus_and_unset_draw_keyfocus (tree_view);
2946           return TRUE;
2947         }
2948
2949       /* find the node that was clicked */
2950       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
2951       if (new_y < 0)
2952         new_y = 0;
2953       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
2954
2955       if (node == NULL)
2956         {
2957           /* We clicked in dead space */
2958           grab_focus_and_unset_draw_keyfocus (tree_view);
2959           return TRUE;
2960         }
2961
2962       /* Get the path and the node */
2963       path = _gtk_tree_path_new_from_rbtree (tree, node);
2964       path_is_selectable = !row_is_separator (tree_view, NULL, path);
2965
2966       if (!path_is_selectable)
2967         {
2968           gtk_tree_path_free (path);
2969           grab_focus_and_unset_draw_keyfocus (tree_view);
2970           return TRUE;
2971         }
2972
2973       depth = gtk_tree_path_get_depth (path);
2974       background_area.y = y_offset + event->y;
2975       background_area.height = gtk_tree_view_get_row_height (tree_view, node);
2976       background_area.x = 0;
2977
2978
2979       /* Let the column have a chance at selecting it. */
2980       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2981       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2982            list; list = (rtl ? list->prev : list->next))
2983         {
2984           GtkTreeViewColumn *candidate = list->data;
2985
2986           if (!gtk_tree_view_column_get_visible (candidate))
2987             continue;
2988
2989           background_area.width = gtk_tree_view_column_get_width (candidate);
2990           if ((background_area.x > (gint) event->x) ||
2991               (background_area.x + background_area.width <= (gint) event->x))
2992             {
2993               background_area.x += background_area.width;
2994               continue;
2995             }
2996
2997           /* we found the focus column */
2998           column = candidate;
2999           cell_area = background_area;
3000           cell_area.width -= horizontal_separator;
3001           cell_area.height -= vertical_separator;
3002           cell_area.x += horizontal_separator/2;
3003           cell_area.y += vertical_separator/2;
3004           if (gtk_tree_view_is_expander_column (tree_view, column))
3005             {
3006               if (!rtl)
3007                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
3008               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
3009
3010               if (gtk_tree_view_draw_expanders (tree_view))
3011                 {
3012                   gint expander_size = gtk_tree_view_get_expander_size (tree_view);
3013                   if (!rtl)
3014                     cell_area.x += depth * expander_size;
3015                   cell_area.width -= depth * expander_size;
3016                 }
3017             }
3018           break;
3019         }
3020
3021       if (column == NULL)
3022         {
3023           gtk_tree_path_free (path);
3024           grab_focus_and_unset_draw_keyfocus (tree_view);
3025           return FALSE;
3026         }
3027
3028       _gtk_tree_view_set_focus_column (tree_view, column);
3029
3030       /* decide if we edit */
3031       if (event->type == GDK_BUTTON_PRESS && event->button == GDK_BUTTON_PRIMARY &&
3032           !(event->state & gtk_accelerator_get_default_mod_mask ()))
3033         {
3034           GtkTreePath *anchor;
3035           GtkTreeIter iter;
3036
3037           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
3038           gtk_tree_view_column_cell_set_cell_data (column,
3039                                                    tree_view->priv->model,
3040                                                    &iter,
3041                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
3042                                                    node->children?TRUE:FALSE);
3043
3044           if (tree_view->priv->anchor)
3045             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
3046           else
3047             anchor = NULL;
3048
3049           if ((anchor && !gtk_tree_path_compare (anchor, path))
3050               || !_gtk_tree_view_column_has_editable_cell (column))
3051             {
3052               GtkCellEditable *cell_editable = NULL;
3053
3054               /* FIXME: get the right flags */
3055               guint flags = 0;
3056
3057               if (_gtk_tree_view_column_cell_event (column,
3058                                                     (GdkEvent *)event,
3059                                                     &cell_area, flags))
3060                 {
3061                   GtkCellArea *area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
3062                   cell_editable = gtk_cell_area_get_edit_widget (area);
3063
3064                   if (cell_editable != NULL)
3065                     {
3066                       gtk_tree_path_free (path);
3067                       gtk_tree_path_free (anchor);
3068                       return TRUE;
3069                     }
3070                   column_handled_click = TRUE;
3071                 }
3072             }
3073           if (anchor)
3074             gtk_tree_path_free (anchor);
3075         }
3076
3077       extend_mod_mask =
3078         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
3079
3080       modify_mod_mask =
3081         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_MODIFY_SELECTION);
3082
3083       /* select */
3084       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
3085       pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3086
3087       /* we only handle selection modifications on the first button press
3088        */
3089       if (event->type == GDK_BUTTON_PRESS)
3090         {
3091           GtkCellRenderer *focus_cell;
3092
3093           if ((event->state & modify_mod_mask) == modify_mod_mask)
3094             tree_view->priv->modify_selection_pressed = TRUE;
3095           if ((event->state & extend_mod_mask) == extend_mod_mask)
3096             tree_view->priv->extend_selection_pressed = TRUE;
3097
3098           /* We update the focus cell here, this is also needed if the
3099            * column does not contain an editable cell.  In this case,
3100            * GtkCellArea did not receive the event for processing (and
3101            * could not update the focus cell).
3102            */
3103           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column,
3104                                                               &cell_area,
3105                                                               &background_area,
3106                                                               event->x,
3107                                                               event->y);
3108
3109           if (focus_cell)
3110             gtk_tree_view_column_focus_cell (column, focus_cell);
3111
3112           if (event->state & modify_mod_mask)
3113             {
3114               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3115               gtk_tree_view_real_toggle_cursor_row (tree_view);
3116             }
3117           else if (event->state & extend_mod_mask)
3118             {
3119               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
3120               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
3121             }
3122           else
3123             {
3124               gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
3125             }
3126
3127           tree_view->priv->modify_selection_pressed = FALSE;
3128           tree_view->priv->extend_selection_pressed = FALSE;
3129         }
3130
3131       /* the treeview may have been scrolled because of _set_cursor,
3132        * correct here
3133        */
3134
3135       aft_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
3136       dval = pre_val - aft_val;
3137
3138       cell_area.y += dval;
3139       background_area.y += dval;
3140
3141       /* Save press to possibly begin a drag
3142        */
3143       if (!column_handled_click &&
3144           !tree_view->priv->in_grab &&
3145           tree_view->priv->pressed_button < 0)
3146         {
3147           tree_view->priv->pressed_button = event->button;
3148           tree_view->priv->press_start_x = event->x;
3149           tree_view->priv->press_start_y = event->y;
3150
3151           if (tree_view->priv->rubber_banding_enable
3152               && !node_selected
3153               && gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
3154             {
3155               tree_view->priv->press_start_y += tree_view->priv->dy;
3156               tree_view->priv->rubber_band_x = event->x;
3157               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
3158               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
3159
3160               if ((event->state & modify_mod_mask) == modify_mod_mask)
3161                 tree_view->priv->rubber_band_modify = TRUE;
3162               if ((event->state & extend_mod_mask) == extend_mod_mask)
3163                 tree_view->priv->rubber_band_extend = TRUE;
3164             }
3165         }
3166
3167       if (event->button == GDK_BUTTON_PRIMARY && event->type == GDK_BUTTON_PRESS)
3168         {
3169
3170           /* Test if a double click happened on the same row. */
3171           if (!tree_view->priv->activate_on_single_click)
3172             {
3173               int double_click_time, double_click_distance;
3174
3175               g_object_get (gtk_settings_get_default (),
3176                             "gtk-double-click-time", &double_click_time,
3177                             "gtk-double-click-distance", &double_click_distance,
3178                             NULL);
3179
3180               /* Same conditions as _gdk_event_button_generate */
3181               if (tree_view->priv->last_button_x != -1 &&
3182                   (event->time < tree_view->priv->last_button_time + double_click_time) &&
3183                   (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
3184                   (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
3185                 {
3186                   /* We do no longer compare paths of this row and the
3187                    * row clicked previously.  We use the double click
3188                    * distance to decide whether this is a valid click,
3189                    * allowing the mouse to slightly move over another row.
3190                    */
3191                   row_double_click = TRUE;
3192
3193                   tree_view->priv->last_button_time = 0;
3194                   tree_view->priv->last_button_x = -1;
3195                   tree_view->priv->last_button_y = -1;
3196                 }
3197               else
3198                 {
3199                   tree_view->priv->last_button_time = event->time;
3200                   tree_view->priv->last_button_x = event->x;
3201                   tree_view->priv->last_button_y = event->y;
3202                 }
3203             }
3204           else
3205             {
3206               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
3207               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
3208             }
3209         }
3210
3211       if (row_double_click)
3212         {
3213           gtk_grab_remove (widget);
3214           gtk_tree_view_row_activated (tree_view, path, column);
3215
3216           if (tree_view->priv->pressed_button == event->button)
3217             tree_view->priv->pressed_button = -1;
3218         }
3219
3220       gtk_tree_path_free (path);
3221
3222       /* If we activated the row through a double click we don't want to grab
3223        * focus back, as moving focus to another widget is pretty common.
3224        */
3225       if (!row_double_click)
3226         grab_focus_and_unset_draw_keyfocus (tree_view);
3227
3228       return TRUE;
3229     }
3230
3231   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
3232    */
3233   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
3234     {
3235       column = list->data;
3236       if (event->window == _gtk_tree_view_column_get_window (column) &&
3237           gtk_tree_view_column_get_resizable (column) &&
3238           _gtk_tree_view_column_get_window (column))
3239         {
3240           gpointer drag_data;
3241           gint column_width, x;
3242
3243           if (event->type == GDK_2BUTTON_PRESS &&
3244               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
3245             {
3246               gtk_tree_view_column_set_fixed_width (column, -1);
3247               gtk_tree_view_column_set_expand (column, FALSE);
3248               _gtk_tree_view_column_autosize (tree_view, column);
3249               return TRUE;
3250             }
3251
3252           if (gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
3253                                _gtk_tree_view_column_get_window (column),
3254                                GDK_OWNERSHIP_NONE,
3255                                FALSE,
3256                                GDK_POINTER_MOTION_HINT_MASK
3257                                 | GDK_BUTTON1_MOTION_MASK
3258                                 | GDK_BUTTON_RELEASE_MASK,
3259                                NULL,
3260                                event->time) != GDK_GRAB_SUCCESS)
3261             return FALSE;
3262
3263           gtk_grab_add (widget);
3264           tree_view->priv->in_column_resize = TRUE;
3265
3266           /* block attached dnd signal handler */
3267           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3268           if (drag_data)
3269             g_signal_handlers_block_matched (widget,
3270                                              G_SIGNAL_MATCH_DATA,
3271                                              0, 0, NULL, NULL,
3272                                              drag_data);
3273
3274           column_width = gtk_tree_view_column_get_width (column);
3275           gdk_window_get_device_position (tree_view->priv->bin_window,
3276                                           gdk_event_get_device ((GdkEvent *) event),
3277                                           &x, NULL, NULL);
3278
3279           tree_view->priv->drag_pos = i;
3280           tree_view->priv->x_drag = x + (rtl ? column_width : -column_width);
3281
3282           if (!gtk_widget_has_focus (widget))
3283             gtk_widget_grab_focus (widget);
3284
3285           return TRUE;
3286         }
3287     }
3288   return FALSE;
3289 }
3290
3291 /* GtkWidget::button_release_event helper */
3292 static gboolean
3293 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
3294                                           GdkEventButton *event)
3295 {
3296   GtkTreeView *tree_view;
3297   GtkWidget *button;
3298   GList *l;
3299   gboolean rtl;
3300   GdkDevice *device, *other;
3301   GtkStyleContext *context;
3302
3303   tree_view = GTK_TREE_VIEW (widget);
3304
3305   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
3306   device = gdk_event_get_device ((GdkEvent*)event);
3307   other = gdk_device_get_associated_device (device);
3308   gdk_device_ungrab (device, event->time);
3309   gdk_device_ungrab (other, event->time);
3310
3311   /* Move the button back */
3312   button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3313
3314   context = gtk_widget_get_style_context (button);
3315   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_DND);
3316
3317   g_object_ref (button);
3318   gtk_container_remove (GTK_CONTAINER (tree_view), button);
3319   gtk_widget_set_parent_window (button, tree_view->priv->header_window);
3320   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
3321   g_object_unref (button);
3322   gtk_widget_queue_resize (widget);
3323   if (gtk_tree_view_column_get_resizable (tree_view->priv->drag_column))
3324     {
3325       gdk_window_raise (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3326       gdk_window_show (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3327     }
3328   else
3329     gdk_window_hide (_gtk_tree_view_column_get_window (tree_view->priv->drag_column));
3330
3331   gtk_widget_grab_focus (button);
3332
3333   if (rtl)
3334     {
3335       if (tree_view->priv->cur_reorder &&
3336           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
3337         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3338                                          tree_view->priv->cur_reorder->right_column);
3339     }
3340   else
3341     {
3342       if (tree_view->priv->cur_reorder &&
3343           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
3344         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
3345                                          tree_view->priv->cur_reorder->left_column);
3346     }
3347   tree_view->priv->drag_column = NULL;
3348   gtk_widget_unregister_window (widget, tree_view->priv->drag_window);
3349   gdk_window_destroy (tree_view->priv->drag_window);
3350   tree_view->priv->drag_window = NULL;
3351
3352   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
3353     g_slice_free (GtkTreeViewColumnReorder, l->data);
3354   g_list_free (tree_view->priv->column_drag_info);
3355   tree_view->priv->column_drag_info = NULL;
3356   tree_view->priv->cur_reorder = NULL;
3357
3358   if (tree_view->priv->drag_highlight_window)
3359     gdk_window_hide (tree_view->priv->drag_highlight_window);
3360
3361   /* Reset our flags */
3362   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
3363   tree_view->priv->in_column_drag = FALSE;
3364
3365   return TRUE;
3366 }
3367
3368 /* GtkWidget::button_release_event helper */
3369 static gboolean
3370 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
3371                                             GdkEventButton *event)
3372 {
3373   GtkTreeView *tree_view;
3374   gpointer drag_data;
3375
3376   tree_view = GTK_TREE_VIEW (widget);
3377
3378   tree_view->priv->drag_pos = -1;
3379
3380   /* unblock attached dnd signal handler */
3381   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3382   if (drag_data)
3383     g_signal_handlers_unblock_matched (widget,
3384                                        G_SIGNAL_MATCH_DATA,
3385                                        0, 0, NULL, NULL,
3386                                        drag_data);
3387
3388   tree_view->priv->in_column_resize = FALSE;
3389   gtk_grab_remove (widget);
3390   gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
3391   return TRUE;
3392 }
3393
3394 static gboolean
3395 button_event_modifies_selection (GdkEventButton *event)
3396 {
3397         return (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) != 0;
3398 }
3399
3400 static gboolean
3401 gtk_tree_view_button_release (GtkWidget      *widget,
3402                               GdkEventButton *event)
3403 {
3404   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3405
3406   if (tree_view->priv->in_column_drag)
3407     return gtk_tree_view_button_release_drag_column (widget, event);
3408
3409   if (tree_view->priv->rubber_band_status)
3410     gtk_tree_view_stop_rubber_band (tree_view);
3411
3412   if (tree_view->priv->pressed_button == event->button)
3413     tree_view->priv->pressed_button = -1;
3414
3415   if (tree_view->priv->in_column_resize)
3416     return gtk_tree_view_button_release_column_resize (widget, event);
3417
3418   if (tree_view->priv->button_pressed_node == NULL)
3419     return FALSE;
3420
3421   if (event->button == GDK_BUTTON_PRIMARY
3422       && tree_view->priv->button_pressed_node == tree_view->priv->prelight_node)
3423     {
3424       if (tree_view->priv->arrow_prelit)
3425         {
3426           GtkTreePath *path = NULL;
3427
3428           path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
3429                                                  tree_view->priv->button_pressed_node);
3430           /* Actually activate the node */
3431           if (tree_view->priv->button_pressed_node->children == NULL)
3432             gtk_tree_view_real_expand_row (tree_view, path,
3433                                            tree_view->priv->button_pressed_tree,
3434                                            tree_view->priv->button_pressed_node,
3435                                            FALSE, TRUE);
3436           else
3437             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3438                                              tree_view->priv->button_pressed_tree,
3439                                              tree_view->priv->button_pressed_node, TRUE);
3440           gtk_tree_path_free (path);
3441         }
3442       else if (tree_view->priv->activate_on_single_click
3443                && !button_event_modifies_selection (event))
3444         {
3445           GtkTreePath *path = NULL;
3446
3447           path = _gtk_tree_path_new_from_rbtree (tree_view->priv->button_pressed_tree,
3448                                                  tree_view->priv->button_pressed_node);
3449           gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
3450           gtk_tree_path_free (path);
3451         }
3452
3453       gtk_grab_remove (widget);
3454       tree_view->priv->button_pressed_tree = NULL;
3455       tree_view->priv->button_pressed_node = NULL;
3456     }
3457
3458   return TRUE;
3459 }
3460
3461 static gboolean
3462 gtk_tree_view_grab_broken (GtkWidget          *widget,
3463                            GdkEventGrabBroken *event)
3464 {
3465   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3466
3467   if (tree_view->priv->in_column_drag)
3468     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3469
3470   if (tree_view->priv->in_column_resize)
3471     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3472
3473   return TRUE;
3474 }
3475
3476 #if 0
3477 static gboolean
3478 gtk_tree_view_configure (GtkWidget *widget,
3479                          GdkEventConfigure *event)
3480 {
3481   GtkTreeView *tree_view;
3482
3483   tree_view = GTK_TREE_VIEW (widget);
3484   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3485
3486   return FALSE;
3487 }
3488 #endif
3489
3490 /* GtkWidget::motion_event function set.
3491  */
3492
3493 static gboolean
3494 coords_are_over_arrow (GtkTreeView *tree_view,
3495                        GtkRBTree   *tree,
3496                        GtkRBNode   *node,
3497                        /* these are in bin window coords */
3498                        gint         x,
3499                        gint         y)
3500 {
3501   GdkRectangle arrow;
3502   gint x2;
3503
3504   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
3505     return FALSE;
3506
3507   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3508     return FALSE;
3509
3510   arrow.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
3511   arrow.height = gtk_tree_view_get_row_height (tree_view, node);
3512
3513   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3514
3515   arrow.width = x2 - arrow.x;
3516
3517   return (x >= arrow.x &&
3518           x < (arrow.x + arrow.width) &&
3519           y >= arrow.y &&
3520           y < (arrow.y + arrow.height));
3521 }
3522
3523 static gboolean
3524 auto_expand_timeout (gpointer data)
3525 {
3526   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3527   GtkTreePath *path;
3528
3529   if (tree_view->priv->prelight_node)
3530     {
3531       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->prelight_tree,
3532                                              tree_view->priv->prelight_node);
3533
3534       if (tree_view->priv->prelight_node->children)
3535         gtk_tree_view_collapse_row (tree_view, path);
3536       else
3537         gtk_tree_view_expand_row (tree_view, path, FALSE);
3538
3539       gtk_tree_path_free (path);
3540     }
3541
3542   tree_view->priv->auto_expand_timeout = 0;
3543
3544   return FALSE;
3545 }
3546
3547 static void
3548 remove_auto_expand_timeout (GtkTreeView *tree_view)
3549 {
3550   if (tree_view->priv->auto_expand_timeout != 0)
3551     {
3552       g_source_remove (tree_view->priv->auto_expand_timeout);
3553       tree_view->priv->auto_expand_timeout = 0;
3554     }
3555 }
3556
3557 static void
3558 do_prelight (GtkTreeView *tree_view,
3559              GtkRBTree   *tree,
3560              GtkRBNode   *node,
3561              /* these are in bin_window coords */
3562              gint         x,
3563              gint         y)
3564 {
3565   if (tree_view->priv->prelight_tree == tree &&
3566       tree_view->priv->prelight_node == node)
3567     {
3568       /*  We are still on the same node,
3569           but we might need to take care of the arrow  */
3570
3571       if (tree && node && gtk_tree_view_draw_expanders (tree_view))
3572         {
3573           gboolean over_arrow;
3574
3575           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3576
3577           if (over_arrow != tree_view->priv->arrow_prelit)
3578             {
3579               if (over_arrow)
3580                 tree_view->priv->arrow_prelit = TRUE;
3581               else
3582                 tree_view->priv->arrow_prelit = FALSE;
3583
3584               gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3585             }
3586         }
3587
3588       return;
3589     }
3590
3591   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3592     {
3593       /*  Unprelight the old node and arrow  */
3594
3595       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3596                              GTK_RBNODE_IS_PRELIT);
3597
3598       if (tree_view->priv->arrow_prelit
3599           && gtk_tree_view_draw_expanders (tree_view))
3600         {
3601           tree_view->priv->arrow_prelit = FALSE;
3602
3603           gtk_tree_view_queue_draw_arrow (tree_view,
3604                                           tree_view->priv->prelight_tree,
3605                                           tree_view->priv->prelight_node);
3606         }
3607
3608       _gtk_tree_view_queue_draw_node (tree_view,
3609                                       tree_view->priv->prelight_tree,
3610                                       tree_view->priv->prelight_node,
3611                                       NULL);
3612     }
3613
3614
3615   if (tree_view->priv->hover_expand)
3616     remove_auto_expand_timeout (tree_view);
3617
3618   /*  Set the new prelight values  */
3619   tree_view->priv->prelight_node = node;
3620   tree_view->priv->prelight_tree = tree;
3621
3622   if (!node || !tree)
3623     return;
3624
3625   /*  Prelight the new node and arrow  */
3626
3627   if (gtk_tree_view_draw_expanders (tree_view)
3628       && coords_are_over_arrow (tree_view, tree, node, x, y))
3629     {
3630       tree_view->priv->arrow_prelit = TRUE;
3631
3632       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3633     }
3634
3635   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3636
3637   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3638
3639   if (tree_view->priv->hover_expand)
3640     {
3641       tree_view->priv->auto_expand_timeout =
3642         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3643     }
3644 }
3645
3646 static void
3647 prelight_or_select (GtkTreeView *tree_view,
3648                     GtkRBTree   *tree,
3649                     GtkRBNode   *node,
3650                     /* these are in bin_window coords */
3651                     gint         x,
3652                     gint         y)
3653 {
3654   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3655
3656   if (tree_view->priv->hover_selection &&
3657       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3658       !(tree_view->priv->edited_column &&
3659         gtk_cell_area_get_edit_widget
3660         (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column)))))
3661     {
3662       if (node)
3663         {
3664           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3665             {
3666               GtkTreePath *path;
3667
3668               path = _gtk_tree_path_new_from_rbtree (tree, node);
3669               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3670               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3671                 {
3672                   tree_view->priv->draw_keyfocus = FALSE;
3673                   gtk_tree_view_real_set_cursor (tree_view, path, 0);
3674                 }
3675               gtk_tree_path_free (path);
3676             }
3677         }
3678
3679       else if (mode == GTK_SELECTION_SINGLE)
3680         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3681     }
3682
3683     do_prelight (tree_view, tree, node, x, y);
3684 }
3685
3686 static void
3687 ensure_unprelighted (GtkTreeView *tree_view)
3688 {
3689   do_prelight (tree_view,
3690                NULL, NULL,
3691                -1000, -1000); /* coords not possibly over an arrow */
3692
3693   g_assert (tree_view->priv->prelight_node == NULL);
3694 }
3695
3696 static void
3697 update_prelight (GtkTreeView *tree_view,
3698                  gint         x,
3699                  gint         y)
3700 {
3701   int new_y;
3702   GtkRBTree *tree;
3703   GtkRBNode *node;
3704
3705   if (tree_view->priv->tree == NULL)
3706     return;
3707
3708   if (x == -10000)
3709     {
3710       ensure_unprelighted (tree_view);
3711       return;
3712     }
3713
3714   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
3715   if (new_y < 0)
3716     new_y = 0;
3717
3718   _gtk_rbtree_find_offset (tree_view->priv->tree,
3719                            new_y, &tree, &node);
3720
3721   if (node)
3722     prelight_or_select (tree_view, tree, node, x, y);
3723 }
3724
3725
3726
3727
3728 /* Our motion arrow is either a box (in the case of the original spot)
3729  * or an arrow.  It is expander_size wide.
3730  */
3731 /*
3732  * 11111111111111
3733  * 01111111111110
3734  * 00111111111100
3735  * 00011111111000
3736  * 00001111110000
3737  * 00000111100000
3738  * 00000111100000
3739  * 00000111100000
3740  * ~ ~ ~ ~ ~ ~ ~
3741  * 00000111100000
3742  * 00000111100000
3743  * 00000111100000
3744  * 00001111110000
3745  * 00011111111000
3746  * 00111111111100
3747  * 01111111111110
3748  * 11111111111111
3749  */
3750
3751 static void
3752 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3753 {
3754   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3755   GtkWidget *widget = GTK_WIDGET (tree_view);
3756   cairo_surface_t *mask_image;
3757   cairo_region_t *mask_region;
3758   gint x;
3759   gint y;
3760   gint width;
3761   gint height;
3762   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3763   GdkWindowAttr attributes;
3764   guint attributes_mask;
3765   cairo_t *cr;
3766
3767   if (!reorder ||
3768       reorder->left_column == tree_view->priv->drag_column ||
3769       reorder->right_column == tree_view->priv->drag_column)
3770     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3771   else if (reorder->left_column || reorder->right_column)
3772     {
3773       GtkAllocation left_allocation, right_allocation;
3774       GdkRectangle visible_rect;
3775       GtkWidget *button;
3776
3777       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3778       if (reorder->left_column)
3779         {
3780           button = gtk_tree_view_column_get_button (reorder->left_column);
3781           gtk_widget_get_allocation (button, &left_allocation);
3782           x = left_allocation.x + left_allocation.width;
3783         }
3784       else
3785         {
3786           button = gtk_tree_view_column_get_button (reorder->right_column);
3787           gtk_widget_get_allocation (button, &right_allocation);
3788           x = right_allocation.x;
3789         }
3790
3791       if (x < visible_rect.x)
3792         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3793       else if (x > visible_rect.x + visible_rect.width)
3794         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3795       else
3796         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3797     }
3798
3799   /* We want to draw the rectangle over the initial location. */
3800   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3801     {
3802       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3803         {
3804           GtkAllocation drag_allocation;
3805           GtkWidget    *button;
3806
3807           if (tree_view->priv->drag_highlight_window)
3808             {
3809               gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3810               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3811             }
3812
3813           button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
3814           attributes.window_type = GDK_WINDOW_CHILD;
3815           attributes.wclass = GDK_INPUT_OUTPUT;
3816           attributes.x = tree_view->priv->drag_column_x;
3817           attributes.y = 0;
3818           gtk_widget_get_allocation (button, &drag_allocation);
3819           width = attributes.width = drag_allocation.width;
3820           height = attributes.height = drag_allocation.height;
3821           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3822           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3823           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3824           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3825           gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3826
3827           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3828           cr = cairo_create (mask_image);
3829
3830           cairo_rectangle (cr, 1, 1, width - 2, height - 2);
3831           cairo_stroke (cr);
3832           cairo_destroy (cr);
3833
3834           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3835           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3836                                            mask_region, 0, 0);
3837
3838           cairo_region_destroy (mask_region);
3839           cairo_surface_destroy (mask_image);
3840
3841           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3842         }
3843     }
3844   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3845     {
3846       GtkAllocation button_allocation;
3847       GtkWidget    *button;
3848
3849       width = gtk_tree_view_get_expander_size (tree_view);
3850
3851       /* Get x, y, width, height of arrow */
3852       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3853       if (reorder->left_column)
3854         {
3855           button = gtk_tree_view_column_get_button (reorder->left_column);
3856           gtk_widget_get_allocation (button, &button_allocation);
3857           x += button_allocation.x + button_allocation.width - width/2;
3858           height = button_allocation.height;
3859         }
3860       else
3861         {
3862           button = gtk_tree_view_column_get_button (reorder->right_column);
3863           gtk_widget_get_allocation (button, &button_allocation);
3864           x += button_allocation.x - width/2;
3865           height = button_allocation.height;
3866         }
3867       y -= width/2; /* The arrow takes up only half the space */
3868       height += width;
3869
3870       /* Create the new window */
3871       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3872         {
3873           if (tree_view->priv->drag_highlight_window)
3874             {
3875               gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3876               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3877             }
3878
3879           attributes.window_type = GDK_WINDOW_TEMP;
3880           attributes.wclass = GDK_INPUT_OUTPUT;
3881           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3882           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3883           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3884           attributes.x = x;
3885           attributes.y = y;
3886           attributes.width = width;
3887           attributes.height = height;
3888           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3889                                                                    &attributes, attributes_mask);
3890           gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3891
3892           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3893
3894           cr = cairo_create (mask_image);
3895           cairo_move_to (cr, 0, 0);
3896           cairo_line_to (cr, width, 0);
3897           cairo_line_to (cr, width / 2., width / 2);
3898           cairo_move_to (cr, 0, height);
3899           cairo_line_to (cr, width, height);
3900           cairo_line_to (cr, width / 2., height - width / 2.);
3901           cairo_fill (cr);
3902           cairo_destroy (cr);
3903
3904           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3905           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3906                                            mask_region, 0, 0);
3907
3908           cairo_region_destroy (mask_region);
3909           cairo_surface_destroy (mask_image);
3910         }
3911
3912       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3913       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3914     }
3915   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3916            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3917     {
3918       GtkAllocation allocation;
3919       GtkWidget    *button;
3920       gint          expander_size;
3921
3922       expander_size = gtk_tree_view_get_expander_size (tree_view);
3923
3924       /* Get x, y, width, height of arrow */
3925       width = expander_size/2; /* remember, the arrow only takes half the available width */
3926       gdk_window_get_origin (gtk_widget_get_window (widget),
3927                              &x, &y);
3928       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3929         {
3930           gtk_widget_get_allocation (widget, &allocation);
3931           x += allocation.width - width;
3932         }
3933
3934       if (reorder->left_column)
3935         {
3936           button = gtk_tree_view_column_get_button (reorder->left_column);
3937           gtk_widget_get_allocation (button, &allocation);
3938           height = allocation.height;
3939         }
3940       else
3941         {
3942           button = gtk_tree_view_column_get_button (reorder->right_column);
3943           gtk_widget_get_allocation (button, &allocation);
3944           height = allocation.height;
3945         }
3946
3947       y -= expander_size;
3948       height += 2 * expander_size;
3949
3950       /* Create the new window */
3951       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3952           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3953         {
3954           if (tree_view->priv->drag_highlight_window)
3955             {
3956               gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3957               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3958             }
3959
3960           attributes.window_type = GDK_WINDOW_TEMP;
3961           attributes.wclass = GDK_INPUT_OUTPUT;
3962           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3963           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3964           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3965           attributes.x = x;
3966           attributes.y = y;
3967           attributes.width = width;
3968           attributes.height = height;
3969           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget), &attributes, attributes_mask);
3970           gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
3971
3972           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3973
3974           cr = cairo_create (mask_image);
3975           /* mirror if we're on the left */
3976           if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3977             {
3978               cairo_translate (cr, width, 0);
3979               cairo_scale (cr, -1, 1);
3980             }
3981           cairo_move_to (cr, 0, 0);
3982           cairo_line_to (cr, width, width);
3983           cairo_line_to (cr, 0, expander_size);
3984           cairo_move_to (cr, 0, height);
3985           cairo_line_to (cr, width, height - width);
3986           cairo_line_to (cr, 0, height - expander_size);
3987           cairo_fill (cr);
3988           cairo_destroy (cr);
3989
3990           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3991           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3992                                            mask_region, 0, 0);
3993
3994           cairo_region_destroy (mask_region);
3995           cairo_surface_destroy (mask_image);
3996         }
3997
3998       tree_view->priv->drag_column_window_state = arrow_type;
3999       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
4000    }
4001   else
4002     {
4003       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
4004       gdk_window_hide (tree_view->priv->drag_highlight_window);
4005       return;
4006     }
4007
4008   gdk_window_show (tree_view->priv->drag_highlight_window);
4009   gdk_window_raise (tree_view->priv->drag_highlight_window);
4010 }
4011
4012 static gboolean
4013 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
4014                                     GdkEventMotion *event)
4015 {
4016   gint x;
4017   gint new_width;
4018   GtkTreeViewColumn *column;
4019   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4020
4021   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
4022
4023   gdk_window_get_device_position (tree_view->priv->bin_window,
4024                                   gdk_event_get_device ((GdkEvent *) event),
4025                                   &x, NULL, NULL);
4026
4027   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
4028     new_width = MAX (tree_view->priv->x_drag - x, 0);
4029   else
4030     new_width = MAX (x - tree_view->priv->x_drag, 0);
4031
4032   if (new_width != gtk_tree_view_column_get_width (column))
4033     gtk_tree_view_modify_column_width (tree_view, column, new_width);
4034
4035   return FALSE;
4036 }
4037
4038
4039 static void
4040 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view,
4041                                       GdkEvent    *event)
4042 {
4043   GtkTreeViewColumnReorder *reorder = NULL;
4044   GList *list;
4045   gint mouse_x;
4046
4047   gdk_window_get_device_position (tree_view->priv->header_window,
4048                                   gdk_event_get_device (event),
4049                                   &mouse_x, NULL, NULL);
4050   for (list = tree_view->priv->column_drag_info; list; list = list->next)
4051     {
4052       reorder = (GtkTreeViewColumnReorder *) list->data;
4053       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
4054         break;
4055       reorder = NULL;
4056     }
4057
4058   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
4059       return;*/
4060
4061   tree_view->priv->cur_reorder = reorder;
4062   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
4063 }
4064
4065 static void
4066 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
4067 {
4068   GdkRectangle visible_rect;
4069   gint y;
4070   gint offset;
4071
4072   gdk_window_get_device_position (tree_view->priv->bin_window,
4073                                   gdk_device_manager_get_client_pointer (
4074                                     gdk_display_get_device_manager (
4075                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4076                                   NULL, &y, NULL);
4077   y += tree_view->priv->dy;
4078
4079   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4080
4081   /* see if we are near the edge. */
4082   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
4083   if (offset > 0)
4084     {
4085       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
4086       if (offset < 0)
4087         return;
4088     }
4089
4090   gtk_adjustment_set_value (tree_view->priv->vadjustment,
4091                             MAX (gtk_adjustment_get_value (tree_view->priv->vadjustment) + offset, 0.0));
4092 }
4093
4094 static gboolean
4095 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view,
4096                                      GdkEvent    *event)
4097 {
4098   GdkRectangle visible_rect;
4099   gint x;
4100   gint offset;
4101
4102   gdk_window_get_device_position (tree_view->priv->bin_window,
4103                                   gdk_event_get_device (event),
4104                                   &x, NULL, NULL);
4105
4106   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
4107
4108   /* See if we are near the edge. */
4109   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
4110   if (offset > 0)
4111     {
4112       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
4113       if (offset < 0)
4114         return TRUE;
4115     }
4116   offset = offset/3;
4117
4118   gtk_adjustment_set_value (tree_view->priv->hadjustment,
4119                             MAX (gtk_adjustment_get_value (tree_view->priv->hadjustment) + offset, 0.0));
4120
4121   return TRUE;
4122
4123 }
4124
4125 static gboolean
4126 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
4127                                   GdkEventMotion *event)
4128 {
4129   GtkAllocation allocation, button_allocation;
4130   GtkTreeView *tree_view = (GtkTreeView *) widget;
4131   GtkTreeViewColumn *column = tree_view->priv->drag_column;
4132   GtkWidget *button;
4133   gint x, y;
4134
4135   /* Sanity Check */
4136   if ((column == NULL) ||
4137       (event->window != tree_view->priv->drag_window))
4138     return FALSE;
4139
4140   button = gtk_tree_view_column_get_button (column);
4141
4142   /* Handle moving the header */
4143   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
4144   gtk_widget_get_allocation (widget, &allocation);
4145   gtk_widget_get_allocation (button, &button_allocation);
4146   x = CLAMP (x + (gint)event->x - _gtk_tree_view_column_get_drag_x (column), 0,
4147              MAX (tree_view->priv->width, allocation.width) - button_allocation.width);
4148   gdk_window_move (tree_view->priv->drag_window, x, y);
4149
4150   /* autoscroll, if needed */
4151   gtk_tree_view_horizontal_autoscroll (tree_view, (GdkEvent *) event);
4152   /* Update the current reorder position and arrow; */
4153   gtk_tree_view_update_current_reorder (tree_view, (GdkEvent *) event);
4154
4155   return TRUE;
4156 }
4157
4158 static void
4159 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
4160 {
4161   remove_scroll_timeout (tree_view);
4162   gtk_grab_remove (GTK_WIDGET (tree_view));
4163
4164   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4165     {
4166       GtkTreePath *tmp_path;
4167
4168       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4169
4170       /* The anchor path should be set to the start path */
4171       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_start_tree,
4172                                                  tree_view->priv->rubber_band_start_node);
4173
4174       if (tree_view->priv->anchor)
4175         gtk_tree_row_reference_free (tree_view->priv->anchor);
4176
4177       tree_view->priv->anchor =
4178         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
4179                                           tree_view->priv->model,
4180                                           tmp_path);
4181
4182       gtk_tree_path_free (tmp_path);
4183
4184       /* ... and the cursor to the end path */
4185       tmp_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->rubber_band_end_tree,
4186                                                  tree_view->priv->rubber_band_end_node);
4187       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, 0);
4188       gtk_tree_path_free (tmp_path);
4189
4190       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
4191     }
4192
4193   /* Clear status variables */
4194   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
4195   tree_view->priv->rubber_band_extend = FALSE;
4196   tree_view->priv->rubber_band_modify = FALSE;
4197
4198   tree_view->priv->rubber_band_start_node = NULL;
4199   tree_view->priv->rubber_band_start_tree = NULL;
4200   tree_view->priv->rubber_band_end_node = NULL;
4201   tree_view->priv->rubber_band_end_tree = NULL;
4202 }
4203
4204 static void
4205 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
4206                                                  GtkRBTree   *start_tree,
4207                                                  GtkRBNode   *start_node,
4208                                                  GtkRBTree   *end_tree,
4209                                                  GtkRBNode   *end_node,
4210                                                  gboolean     select,
4211                                                  gboolean     skip_start,
4212                                                  gboolean     skip_end)
4213 {
4214   if (start_node == end_node)
4215     return;
4216
4217   /* We skip the first node and jump inside the loop */
4218   if (skip_start)
4219     goto skip_first;
4220
4221   do
4222     {
4223       /* Small optimization by assuming insensitive nodes are never
4224        * selected.
4225        */
4226       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4227         {
4228           GtkTreePath *path;
4229           gboolean selectable;
4230
4231           path = _gtk_tree_path_new_from_rbtree (start_tree, start_node);
4232           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
4233           gtk_tree_path_free (path);
4234
4235           if (!selectable)
4236             goto node_not_selectable;
4237         }
4238
4239       if (select)
4240         {
4241           if (tree_view->priv->rubber_band_extend)
4242             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4243           else if (tree_view->priv->rubber_band_modify)
4244             {
4245               /* Toggle the selection state */
4246               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4247                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4248               else
4249                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4250             }
4251           else
4252             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4253         }
4254       else
4255         {
4256           /* Mirror the above */
4257           if (tree_view->priv->rubber_band_extend)
4258             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4259           else if (tree_view->priv->rubber_band_modify)
4260             {
4261               /* Toggle the selection state */
4262               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
4263                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4264               else
4265                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4266             }
4267           else
4268             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
4269         }
4270
4271       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
4272
4273 node_not_selectable:
4274       if (start_node == end_node)
4275         break;
4276
4277 skip_first:
4278
4279       if (start_node->children)
4280         {
4281           start_tree = start_node->children;
4282           start_node = _gtk_rbtree_first (start_tree);
4283         }
4284       else
4285         {
4286           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
4287
4288           if (!start_tree)
4289             /* Ran out of tree */
4290             break;
4291         }
4292
4293       if (skip_end && start_node == end_node)
4294         break;
4295     }
4296   while (TRUE);
4297 }
4298
4299 static void
4300 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
4301 {
4302   GtkRBTree *start_tree, *end_tree;
4303   GtkRBNode *start_node, *end_node;
4304
4305   _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);
4306   _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);
4307
4308   /* Handle the start area first */
4309   if (!tree_view->priv->rubber_band_start_node)
4310     {
4311       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4312                                                        start_tree,
4313                                                        start_node,
4314                                                        end_tree,
4315                                                        end_node,
4316                                                        TRUE,
4317                                                        FALSE,
4318                                                        FALSE);
4319     }
4320   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
4321            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4322     {
4323       /* New node is above the old one; selection became bigger */
4324       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4325                                                        start_tree,
4326                                                        start_node,
4327                                                        tree_view->priv->rubber_band_start_tree,
4328                                                        tree_view->priv->rubber_band_start_node,
4329                                                        TRUE,
4330                                                        FALSE,
4331                                                        TRUE);
4332     }
4333   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
4334            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
4335     {
4336       /* New node is below the old one; selection became smaller */
4337       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4338                                                        tree_view->priv->rubber_band_start_tree,
4339                                                        tree_view->priv->rubber_band_start_node,
4340                                                        start_tree,
4341                                                        start_node,
4342                                                        FALSE,
4343                                                        FALSE,
4344                                                        TRUE);
4345     }
4346
4347   tree_view->priv->rubber_band_start_tree = start_tree;
4348   tree_view->priv->rubber_band_start_node = start_node;
4349
4350   /* Next, handle the end area */
4351   if (!tree_view->priv->rubber_band_end_node)
4352     {
4353       /* In the event this happens, start_node was also NULL; this case is
4354        * handled above.
4355        */
4356     }
4357   else if (!end_node)
4358     {
4359       /* Find the last node in the tree */
4360       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
4361                                &end_tree, &end_node);
4362
4363       /* Selection reached end of the tree */
4364       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4365                                                        tree_view->priv->rubber_band_end_tree,
4366                                                        tree_view->priv->rubber_band_end_node,
4367                                                        end_tree,
4368                                                        end_node,
4369                                                        TRUE,
4370                                                        TRUE,
4371                                                        FALSE);
4372     }
4373   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
4374            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4375     {
4376       /* New node is below the old one; selection became bigger */
4377       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4378                                                        tree_view->priv->rubber_band_end_tree,
4379                                                        tree_view->priv->rubber_band_end_node,
4380                                                        end_tree,
4381                                                        end_node,
4382                                                        TRUE,
4383                                                        TRUE,
4384                                                        FALSE);
4385     }
4386   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
4387            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4388     {
4389       /* New node is above the old one; selection became smaller */
4390       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4391                                                        end_tree,
4392                                                        end_node,
4393                                                        tree_view->priv->rubber_band_end_tree,
4394                                                        tree_view->priv->rubber_band_end_node,
4395                                                        FALSE,
4396                                                        TRUE,
4397                                                        FALSE);
4398     }
4399
4400   tree_view->priv->rubber_band_end_tree = end_tree;
4401   tree_view->priv->rubber_band_end_node = end_node;
4402 }
4403
4404 static void
4405 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
4406 {
4407   gint x, y;
4408   GdkRectangle old_area;
4409   GdkRectangle new_area;
4410   GdkRectangle common;
4411   cairo_region_t *invalid_region;
4412
4413   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4414   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4415   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
4416   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
4417
4418   gdk_window_get_device_position (tree_view->priv->bin_window,
4419                                   gdk_device_manager_get_client_pointer (
4420                                     gdk_display_get_device_manager (
4421                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
4422                                   &x, &y, NULL);
4423
4424   x = MAX (x, 0);
4425   y = MAX (y, 0) + tree_view->priv->dy;
4426
4427   new_area.x = MIN (tree_view->priv->press_start_x, x);
4428   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
4429   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
4430   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
4431
4432   invalid_region = cairo_region_create_rectangle (&old_area);
4433   cairo_region_union_rectangle (invalid_region, &new_area);
4434
4435   gdk_rectangle_intersect (&old_area, &new_area, &common);
4436   if (common.width > 2 && common.height > 2)
4437     {
4438       cairo_region_t *common_region;
4439
4440       /* make sure the border is invalidated */
4441       common.x += 1;
4442       common.y += 1;
4443       common.width -= 2;
4444       common.height -= 2;
4445
4446       common_region = cairo_region_create_rectangle (&common);
4447
4448       cairo_region_subtract (invalid_region, common_region);
4449       cairo_region_destroy (common_region);
4450     }
4451
4452   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
4453
4454   cairo_region_destroy (invalid_region);
4455
4456   tree_view->priv->rubber_band_x = x;
4457   tree_view->priv->rubber_band_y = y;
4458
4459   gtk_tree_view_update_rubber_band_selection (tree_view);
4460 }
4461
4462 static void
4463 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4464                                  cairo_t      *cr)
4465 {
4466   GdkRectangle rect;
4467   GtkStyleContext *context;
4468
4469   cairo_save (cr);
4470
4471   context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4472
4473   gtk_style_context_save (context);
4474   gtk_style_context_add_class (context, GTK_STYLE_CLASS_RUBBERBAND);
4475
4476   rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4477   rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4478   rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4479   rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4480
4481   gdk_cairo_rectangle (cr, &rect);
4482   cairo_clip (cr);
4483
4484   gtk_render_background (context, cr,
4485                          rect.x, rect.y,
4486                          rect.width, rect.height);
4487   gtk_render_frame (context, cr,
4488                     rect.x, rect.y,
4489                     rect.width, rect.height);
4490
4491   gtk_style_context_restore (context);
4492   cairo_restore (cr);
4493 }
4494
4495 static gboolean
4496 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4497                                  GdkEventMotion *event)
4498 {
4499   GtkTreeView *tree_view;
4500   GtkRBTree *tree;
4501   GtkRBNode *node;
4502   gint new_y;
4503
4504   tree_view = (GtkTreeView *) widget;
4505
4506   if (tree_view->priv->tree == NULL)
4507     return FALSE;
4508
4509   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4510     {
4511       gtk_grab_add (GTK_WIDGET (tree_view));
4512       gtk_tree_view_update_rubber_band (tree_view);
4513
4514       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4515     }
4516   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4517     {
4518       gtk_tree_view_update_rubber_band (tree_view);
4519
4520       add_scroll_timeout (tree_view);
4521     }
4522
4523   /* only check for an initiated drag when a button is pressed */
4524   if (tree_view->priv->pressed_button >= 0
4525       && !tree_view->priv->rubber_band_status)
4526     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4527
4528   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4529   if (new_y < 0)
4530     new_y = 0;
4531
4532   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4533
4534   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4535   if ((tree_view->priv->button_pressed_node != NULL) &&
4536       (tree_view->priv->button_pressed_node != node))
4537     node = NULL;
4538
4539   tree_view->priv->event_last_x = event->x;
4540   tree_view->priv->event_last_y = event->y;
4541
4542   prelight_or_select (tree_view, tree, node, event->x, event->y);
4543
4544   return TRUE;
4545 }
4546
4547 static gboolean
4548 gtk_tree_view_motion (GtkWidget      *widget,
4549                       GdkEventMotion *event)
4550 {
4551   GtkTreeView *tree_view;
4552
4553   tree_view = (GtkTreeView *) widget;
4554
4555   /* Resizing a column */
4556   if (tree_view->priv->in_column_resize)
4557     return gtk_tree_view_motion_resize_column (widget, event);
4558
4559   /* Drag column */
4560   if (tree_view->priv->in_column_drag)
4561     return gtk_tree_view_motion_drag_column (widget, event);
4562
4563   /* Sanity check it */
4564   if (event->window == tree_view->priv->bin_window)
4565     return gtk_tree_view_motion_bin_window (widget, event);
4566
4567   return FALSE;
4568 }
4569
4570 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4571  * the tree is empty.
4572  */
4573 static void
4574 invalidate_empty_focus (GtkTreeView *tree_view)
4575 {
4576   GdkRectangle area;
4577
4578   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
4579     return;
4580
4581   area.x = 0;
4582   area.y = 0;
4583   area.width = gdk_window_get_width (tree_view->priv->bin_window);
4584   area.height = gdk_window_get_height (tree_view->priv->bin_window);
4585   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4586 }
4587
4588 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4589  * is empty.
4590  */
4591 static void
4592 draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr)
4593 {
4594   GtkWidget *widget = GTK_WIDGET (tree_view);
4595   gint w, h;
4596
4597   if (!gtk_widget_has_visible_focus (widget))
4598     return;
4599
4600   w = gdk_window_get_width (tree_view->priv->bin_window) - 2;
4601   h = gdk_window_get_height (tree_view->priv->bin_window) - 2;
4602
4603   if (w > 0 && h > 0)
4604     {
4605       GtkStyleContext *context;
4606
4607       context = gtk_widget_get_style_context (widget);
4608
4609       gtk_render_focus (context, cr, 1, 1, w, h);
4610     }
4611 }
4612
4613 typedef enum {
4614   GTK_TREE_VIEW_GRID_LINE,
4615   GTK_TREE_VIEW_TREE_LINE,
4616   GTK_TREE_VIEW_FOREGROUND_LINE
4617 } GtkTreeViewLineType;
4618
4619 static void
4620 gtk_tree_view_draw_line (GtkTreeView         *tree_view,
4621                          cairo_t             *cr,
4622                          GtkTreeViewLineType  type,
4623                          int                  x1,
4624                          int                  y1,
4625                          int                  x2,
4626                          int                  y2)
4627 {
4628   cairo_save (cr);
4629
4630   switch (type)
4631     {
4632     case GTK_TREE_VIEW_TREE_LINE:
4633       cairo_set_source_rgb (cr, 0, 0, 0);
4634       cairo_set_line_width (cr, tree_view->priv->tree_line_width);
4635       if (tree_view->priv->tree_line_dashes[0])
4636         cairo_set_dash (cr,
4637                         tree_view->priv->tree_line_dashes,
4638                         2, 0.5);
4639       break;
4640     case GTK_TREE_VIEW_GRID_LINE:
4641       cairo_set_source_rgb (cr, 0, 0, 0);
4642       cairo_set_line_width (cr, tree_view->priv->grid_line_width);
4643       if (tree_view->priv->grid_line_dashes[0])
4644         cairo_set_dash (cr,
4645                         tree_view->priv->grid_line_dashes,
4646                         2, 0.5);
4647       break;
4648     default:
4649       g_assert_not_reached ();
4650       /* fall through */
4651     case GTK_TREE_VIEW_FOREGROUND_LINE:
4652       {
4653         GtkStyleContext *context;
4654         GtkStateFlags state;
4655         GdkRGBA color;
4656
4657         context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
4658         state = gtk_widget_get_state_flags (GTK_WIDGET (tree_view));
4659
4660         cairo_set_line_width (cr, 1.0);
4661         gtk_style_context_get_color (context, state, &color);
4662         gdk_cairo_set_source_rgba (cr, &color);
4663       }
4664
4665       break;
4666     }
4667
4668   cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
4669   cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
4670   cairo_stroke (cr);
4671
4672   cairo_restore (cr);
4673 }
4674
4675 static void
4676 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4677                                cairo_t        *cr,
4678                                gint            n_visible_columns)
4679 {
4680   GList *list = tree_view->priv->columns;
4681   gint i = 0;
4682   gint current_x = 0;
4683
4684   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4685       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4686     return;
4687
4688   /* Only draw the lines for visible rows and columns */
4689   for (list = tree_view->priv->columns; list; list = list->next, i++)
4690     {
4691       GtkTreeViewColumn *column = list->data;
4692
4693       /* We don't want a line for the last column */
4694       if (i == n_visible_columns - 1)
4695         break;
4696
4697       if (!gtk_tree_view_column_get_visible (column))
4698         continue;
4699
4700       current_x += gtk_tree_view_column_get_width (column);
4701
4702       gtk_tree_view_draw_line (tree_view, cr,
4703                                GTK_TREE_VIEW_GRID_LINE,
4704                                current_x - 1, 0,
4705                                current_x - 1, tree_view->priv->height);
4706     }
4707 }
4708
4709 /* Warning: Very scary function.
4710  * Modify at your own risk
4711  *
4712  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4713  * FIXME: It's not...
4714  */
4715 static gboolean
4716 gtk_tree_view_bin_draw (GtkWidget      *widget,
4717                         cairo_t        *cr)
4718 {
4719   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4720   GtkTreePath *path;
4721   GtkRBTree *tree;
4722   GList *list;
4723   GtkRBNode *node;
4724   GtkRBNode *drag_highlight = NULL;
4725   GtkRBTree *drag_highlight_tree = NULL;
4726   GtkTreeIter iter;
4727   gint new_y;
4728   gint y_offset, cell_offset;
4729   gint max_height;
4730   gint depth;
4731   GdkRectangle background_area;
4732   GdkRectangle cell_area;
4733   GdkRectangle clip;
4734   guint flags;
4735   gint highlight_x;
4736   gint expander_cell_width;
4737   gint bin_window_width;
4738   gint bin_window_height;
4739   GtkTreePath *drag_dest_path;
4740   GList *first_column, *last_column;
4741   gint vertical_separator;
4742   gint horizontal_separator;
4743   gboolean allow_rules;
4744   gboolean has_can_focus_cell;
4745   gboolean rtl;
4746   gint n_visible_columns;
4747   gint grid_line_width;
4748   gint expander_size;
4749   gboolean draw_vgrid_lines, draw_hgrid_lines;
4750   GtkStyleContext *context;
4751   gboolean parity;
4752
4753   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4754   context = gtk_widget_get_style_context (widget);
4755
4756   gtk_widget_style_get (widget,
4757                         "horizontal-separator", &horizontal_separator,
4758                         "vertical-separator", &vertical_separator,
4759                         "allow-rules", &allow_rules,
4760                         NULL);
4761
4762   if (tree_view->priv->tree == NULL)
4763     {
4764       draw_empty_focus (tree_view, cr);
4765       return TRUE;
4766     }
4767
4768   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
4769   bin_window_height = gdk_window_get_height (tree_view->priv->bin_window);
4770   cairo_rectangle (cr, 0, 0, bin_window_width, bin_window_height);
4771   cairo_clip (cr);
4772   if (!gdk_cairo_get_clip_rectangle (cr, &clip))
4773     return TRUE;
4774
4775   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, clip.y);
4776
4777   if (new_y < 0)
4778     new_y = 0;
4779   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4780
4781   if (tree_view->priv->height < bin_window_height)
4782     {
4783       gtk_style_context_save (context);
4784       gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
4785
4786       gtk_render_background (context, cr,
4787                              0, tree_view->priv->height,
4788                              bin_window_width,
4789                              bin_window_height - tree_view->priv->height);
4790
4791       gtk_style_context_restore (context);
4792     }
4793
4794   if (node == NULL)
4795     return TRUE;
4796
4797   /* find the path for the node */
4798   path = _gtk_tree_path_new_from_rbtree (tree, node);
4799   gtk_tree_model_get_iter (tree_view->priv->model,
4800                            &iter,
4801                            path);
4802   depth = gtk_tree_path_get_depth (path);
4803   gtk_tree_path_free (path);
4804
4805   drag_dest_path = NULL;
4806
4807   if (tree_view->priv->drag_dest_row)
4808     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4809
4810   if (drag_dest_path)
4811     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4812                               &drag_highlight_tree, &drag_highlight);
4813
4814   draw_vgrid_lines =
4815     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4816     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4817   draw_hgrid_lines =
4818     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4819     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4820   expander_size = gtk_tree_view_get_expander_size (tree_view);
4821
4822   if (draw_vgrid_lines || draw_hgrid_lines)
4823     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4824
4825   n_visible_columns = 0;
4826   for (list = tree_view->priv->columns; list; list = list->next)
4827     {
4828       if (!gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
4829         continue;
4830       n_visible_columns ++;
4831     }
4832
4833   /* Find the last column */
4834   for (last_column = g_list_last (tree_view->priv->columns);
4835        last_column &&
4836        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
4837        last_column = last_column->prev)
4838     ;
4839
4840   /* and the first */
4841   for (first_column = g_list_first (tree_view->priv->columns);
4842        first_column &&
4843        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
4844        first_column = first_column->next)
4845     ;
4846
4847   /* Actually process the expose event.  To do this, we want to
4848    * start at the first node of the event, and walk the tree in
4849    * order, drawing each successive node.
4850    */
4851
4852   parity = !(_gtk_rbtree_node_get_index (tree, node) % 2);
4853
4854   do
4855     {
4856       gboolean is_separator = FALSE;
4857       gboolean is_first = FALSE;
4858       gboolean is_last = FALSE;
4859       gint n_col = 0;
4860
4861       parity = !parity;
4862       is_separator = row_is_separator (tree_view, &iter, NULL);
4863
4864       max_height = gtk_tree_view_get_row_height (tree_view, node);
4865
4866       cell_offset = 0;
4867       highlight_x = 0; /* should match x coord of first cell */
4868       expander_cell_width = 0;
4869
4870       background_area.y = y_offset + clip.y;
4871       background_area.height = max_height;
4872
4873       flags = 0;
4874
4875       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4876         flags |= GTK_CELL_RENDERER_PRELIT;
4877
4878       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4879         flags |= GTK_CELL_RENDERER_SELECTED;
4880
4881       /* we *need* to set cell data on all cells before the call
4882        * to _has_can_focus_cell, else _has_can_focus_cell() does not
4883        * return a correct value.
4884        */
4885       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4886            list;
4887            list = (rtl ? list->prev : list->next))
4888         {
4889           GtkTreeViewColumn *column = list->data;
4890           gtk_tree_view_column_cell_set_cell_data (column,
4891                                                    tree_view->priv->model,
4892                                                    &iter,
4893                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4894                                                    node->children?TRUE:FALSE);
4895         }
4896
4897       has_can_focus_cell = gtk_tree_view_has_can_focus_cell (tree_view);
4898
4899       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4900            list;
4901            list = (rtl ? list->prev : list->next))
4902         {
4903           GtkTreeViewColumn *column = list->data;
4904           GtkRegionFlags row_flags = 0, column_flags = 0;
4905           GtkStateFlags state = 0;
4906           gint width;
4907           gboolean draw_focus;
4908
4909           if (!gtk_tree_view_column_get_visible (column))
4910             continue;
4911
4912           n_col++;
4913           width = gtk_tree_view_column_get_width (column);
4914
4915           if (cell_offset > clip.x + clip.width ||
4916               cell_offset + width < clip.x)
4917             {
4918               cell_offset += width;
4919               continue;
4920             }
4921
4922           if (gtk_tree_view_column_get_sort_indicator (column))
4923             flags |= GTK_CELL_RENDERER_SORTED;
4924           else
4925             flags &= ~GTK_CELL_RENDERER_SORTED;
4926
4927           if (tree_view->priv->cursor_node == node)
4928             flags |= GTK_CELL_RENDERER_FOCUSED;
4929           else
4930             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4931
4932           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
4933             flags |= GTK_CELL_RENDERER_EXPANDABLE;
4934           else
4935             flags &= ~GTK_CELL_RENDERER_EXPANDABLE;
4936
4937           if (node->children)
4938             flags |= GTK_CELL_RENDERER_EXPANDED;
4939           else
4940             flags &= ~GTK_CELL_RENDERER_EXPANDED;
4941
4942           background_area.x = cell_offset;
4943           background_area.width = width;
4944
4945           cell_area = background_area;
4946           cell_area.y += vertical_separator / 2;
4947           cell_area.x += horizontal_separator / 2;
4948           cell_area.height -= vertical_separator;
4949           cell_area.width -= horizontal_separator;
4950
4951           if (draw_vgrid_lines)
4952             {
4953               if (list == first_column)
4954                 {
4955                   cell_area.width -= grid_line_width / 2;
4956                 }
4957               else if (list == last_column)
4958                 {
4959                   cell_area.x += grid_line_width / 2;
4960                   cell_area.width -= grid_line_width / 2;
4961                 }
4962               else
4963                 {
4964                   cell_area.x += grid_line_width / 2;
4965                   cell_area.width -= grid_line_width;
4966                 }
4967             }
4968
4969           if (draw_hgrid_lines)
4970             {
4971               cell_area.y += grid_line_width / 2;
4972               cell_area.height -= grid_line_width;
4973             }
4974
4975           if (!gdk_rectangle_intersect (&clip, &background_area, NULL))
4976             {
4977               cell_offset += gtk_tree_view_column_get_width (column);
4978               continue;
4979             }
4980
4981           gtk_tree_view_column_cell_set_cell_data (column,
4982                                                    tree_view->priv->model,
4983                                                    &iter,
4984                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4985                                                    node->children?TRUE:FALSE);
4986
4987           /* Select the detail for drawing the cell.  relevant
4988            * factors are parity, sortedness, and whether to
4989            * display rules.
4990            */
4991           if (allow_rules && tree_view->priv->has_rules)
4992             {
4993               if (parity)
4994                 row_flags |= GTK_REGION_ODD;
4995               else
4996                 row_flags |= GTK_REGION_EVEN;
4997             }
4998
4999           if ((flags & GTK_CELL_RENDERER_SORTED) &&
5000               n_visible_columns >= 3)
5001             column_flags |= GTK_REGION_SORTED;
5002
5003           is_first = (rtl ? !list->next : !list->prev);
5004           is_last = (rtl ? !list->prev : !list->next);
5005
5006           if (is_first)
5007             column_flags |= GTK_REGION_FIRST;
5008
5009           if (is_last)
5010             column_flags |= GTK_REGION_LAST;
5011
5012           if ((n_col % 2) == 0)
5013             column_flags |= GTK_REGION_EVEN;
5014           else
5015             column_flags |= GTK_REGION_ODD;
5016
5017           gtk_style_context_save (context);
5018
5019           state = gtk_cell_renderer_get_state (NULL, widget, flags);
5020           gtk_style_context_set_state (context, state);
5021
5022           gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
5023           gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
5024           gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, column_flags);
5025
5026           if (node == tree_view->priv->cursor_node && has_can_focus_cell
5027               && ((column == tree_view->priv->focus_column
5028                    && tree_view->priv->draw_keyfocus &&
5029                    gtk_widget_has_visible_focus (widget))
5030                   || (column == tree_view->priv->edited_column)))
5031             draw_focus = TRUE;
5032           else
5033             draw_focus = FALSE;
5034
5035           /* Draw background */
5036           gtk_render_background (context, cr,
5037                                  background_area.x,
5038                                  background_area.y,
5039                                  background_area.width,
5040                                  background_area.height);
5041
5042           /* Draw frame */
5043           gtk_render_frame (context, cr,
5044                             background_area.x,
5045                             background_area.y,
5046                             background_area.width,
5047                             background_area.height);
5048
5049           if (gtk_tree_view_is_expander_column (tree_view, column))
5050             {
5051               if (!rtl)
5052                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
5053               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
5054
5055               if (gtk_tree_view_draw_expanders (tree_view))
5056                 {
5057                   int expander_size = gtk_tree_view_get_expander_size (tree_view);
5058                   if (!rtl)
5059                     cell_area.x += depth * expander_size;
5060                   cell_area.width -= depth * expander_size;
5061                 }
5062
5063               /* If we have an expander column, the highlight underline
5064                * starts with that column, so that it indicates which
5065                * level of the tree we're dropping at.
5066                */
5067               highlight_x = cell_area.x;
5068               expander_cell_width = cell_area.width;
5069
5070               if (is_separator)
5071                 {
5072                   gtk_style_context_save (context);
5073                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5074
5075                   gtk_render_line (context, cr,
5076                                    cell_area.x,
5077                                    cell_area.y + cell_area.height / 2,
5078                                    cell_area.x + cell_area.width,
5079                                    cell_area.y + cell_area.height / 2);
5080
5081                   gtk_style_context_restore (context);
5082                 }
5083               else
5084                 {
5085                   _gtk_tree_view_column_cell_render (column,
5086                                                      cr,
5087                                                      &background_area,
5088                                                      &cell_area,
5089                                                      flags,
5090                                                      draw_focus);
5091                 }
5092
5093               if (gtk_tree_view_draw_expanders (tree_view)
5094                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
5095                 {
5096                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
5097                                             cr,
5098                                             tree,
5099                                             node);
5100                 }
5101             }
5102           else
5103             {
5104               if (is_separator)
5105                 {
5106                   gtk_style_context_save (context);
5107                   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
5108
5109                   gtk_render_line (context, cr,
5110                                    cell_area.x,
5111                                    cell_area.y + cell_area.height / 2,
5112                                    cell_area.x + cell_area.width,
5113                                    cell_area.y + cell_area.height / 2);
5114
5115                   gtk_style_context_restore (context);
5116                 }
5117               else
5118                 _gtk_tree_view_column_cell_render (column,
5119                                                    cr,
5120                                                    &background_area,
5121                                                    &cell_area,
5122                                                    flags,
5123                                                    draw_focus);
5124             }
5125
5126           if (draw_hgrid_lines)
5127             {
5128               if (background_area.y > 0)
5129                 gtk_tree_view_draw_line (tree_view, cr,
5130                                          GTK_TREE_VIEW_GRID_LINE,
5131                                          background_area.x, background_area.y,
5132                                          background_area.x + background_area.width,
5133                                          background_area.y);
5134
5135               if (y_offset + max_height >= clip.height)
5136                 gtk_tree_view_draw_line (tree_view, cr,
5137                                          GTK_TREE_VIEW_GRID_LINE,
5138                                          background_area.x, background_area.y + max_height,
5139                                          background_area.x + background_area.width,
5140                                          background_area.y + max_height);
5141             }
5142
5143           if (gtk_tree_view_is_expander_column (tree_view, column) &&
5144               tree_view->priv->tree_lines_enabled)
5145             {
5146               gint x = background_area.x;
5147               gint mult = rtl ? -1 : 1;
5148               gint y0 = background_area.y;
5149               gint y1 = background_area.y + background_area.height/2;
5150               gint y2 = background_area.y + background_area.height;
5151
5152               if (rtl)
5153                 x += background_area.width - 1;
5154
5155               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
5156                   && depth > 1)
5157                 {
5158                   gtk_tree_view_draw_line (tree_view, cr,
5159                                            GTK_TREE_VIEW_TREE_LINE,
5160                                            x + expander_size * (depth - 1.5) * mult,
5161                                            y1,
5162                                            x + expander_size * (depth - 1.1) * mult,
5163                                            y1);
5164                 }
5165               else if (depth > 1)
5166                 {
5167                   gtk_tree_view_draw_line (tree_view, cr,
5168                                            GTK_TREE_VIEW_TREE_LINE,
5169                                            x + expander_size * (depth - 1.5) * mult,
5170                                            y1,
5171                                            x + expander_size * (depth - 0.5) * mult,
5172                                            y1);
5173                 }
5174
5175               if (depth > 1)
5176                 {
5177                   gint i;
5178                   GtkRBNode *tmp_node;
5179                   GtkRBTree *tmp_tree;
5180
5181                   if (!_gtk_rbtree_next (tree, node))
5182                     gtk_tree_view_draw_line (tree_view, cr,
5183                                              GTK_TREE_VIEW_TREE_LINE,
5184                                              x + expander_size * (depth - 1.5) * mult,
5185                                              y0,
5186                                              x + expander_size * (depth - 1.5) * mult,
5187                                              y1);
5188                   else
5189                     gtk_tree_view_draw_line (tree_view, cr,
5190                                              GTK_TREE_VIEW_TREE_LINE,
5191                                              x + expander_size * (depth - 1.5) * mult,
5192                                              y0,
5193                                              x + expander_size * (depth - 1.5) * mult,
5194                                              y2);
5195
5196                   tmp_node = tree->parent_node;
5197                   tmp_tree = tree->parent_tree;
5198
5199                   for (i = depth - 2; i > 0; i--)
5200                     {
5201                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
5202                         gtk_tree_view_draw_line (tree_view, cr,
5203                                                  GTK_TREE_VIEW_TREE_LINE,
5204                                                  x + expander_size * (i - 0.5) * mult,
5205                                                  y0,
5206                                                  x + expander_size * (i - 0.5) * mult,
5207                                                  y2);
5208
5209                       tmp_node = tmp_tree->parent_node;
5210                       tmp_tree = tmp_tree->parent_tree;
5211                     }
5212                 }
5213             }
5214
5215           gtk_style_context_restore (context);
5216           cell_offset += gtk_tree_view_column_get_width (column);
5217         }
5218
5219       if (node == drag_highlight)
5220         {
5221           /* Draw indicator for the drop
5222            */
5223           gint highlight_y = -1;
5224           GtkRBTree *tree = NULL;
5225           GtkRBNode *node = NULL;
5226
5227           gtk_style_context_save (context);
5228           gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND);
5229
5230           switch (tree_view->priv->drag_dest_pos)
5231             {
5232             case GTK_TREE_VIEW_DROP_BEFORE:
5233               highlight_y = background_area.y - 1;
5234               if (highlight_y < 0)
5235                       highlight_y = 0;
5236               break;
5237
5238             case GTK_TREE_VIEW_DROP_AFTER:
5239               highlight_y = background_area.y + background_area.height - 1;
5240               break;
5241
5242             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
5243             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
5244               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
5245
5246               if (tree == NULL)
5247                 break;
5248
5249               gtk_render_frame (context, cr,
5250                                 0, gtk_tree_view_get_row_y_offset (tree_view, tree, node),
5251                                 gdk_window_get_width (tree_view->priv->bin_window),
5252                                 gtk_tree_view_get_row_height (tree_view, node));
5253               break;
5254             }
5255
5256           if (highlight_y >= 0)
5257             {
5258               gtk_tree_view_draw_line (tree_view, cr,
5259                                        GTK_TREE_VIEW_FOREGROUND_LINE,
5260                                        rtl ? highlight_x + expander_cell_width : highlight_x,
5261                                        highlight_y,
5262                                        rtl ? 0 : bin_window_width,
5263                                        highlight_y);
5264             }
5265
5266           gtk_style_context_restore (context);
5267         }
5268
5269       /* draw the big row-spanning focus rectangle, if needed */
5270       if (!has_can_focus_cell && node == tree_view->priv->cursor_node &&
5271           tree_view->priv->draw_keyfocus &&
5272           gtk_widget_has_visible_focus (widget))
5273         {
5274           gint tmp_y, tmp_height;
5275           GtkStateFlags focus_rect_state = 0;
5276
5277           gtk_style_context_save (context);
5278
5279           focus_rect_state = gtk_cell_renderer_get_state (NULL, widget, flags);
5280           gtk_style_context_set_state (context, focus_rect_state);
5281
5282           if (draw_hgrid_lines)
5283             {
5284               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node) + grid_line_width / 2;
5285               tmp_height = gtk_tree_view_get_row_height (tree_view, node) - grid_line_width;
5286             }
5287           else
5288             {
5289               tmp_y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
5290               tmp_height = gtk_tree_view_get_row_height (tree_view, node);
5291             }
5292
5293           gtk_render_focus (context, cr,
5294                             0, tmp_y,
5295                             gdk_window_get_width (tree_view->priv->bin_window),
5296                             tmp_height);
5297
5298           gtk_style_context_restore (context);
5299         }
5300
5301       y_offset += max_height;
5302       if (node->children)
5303         {
5304           GtkTreeIter parent = iter;
5305           gboolean has_child;
5306
5307           tree = node->children;
5308           node = _gtk_rbtree_first (tree);
5309
5310           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
5311                                                     &iter,
5312                                                     &parent);
5313           depth++;
5314
5315           /* Sanity Check! */
5316           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
5317         }
5318       else
5319         {
5320           gboolean done = FALSE;
5321
5322           do
5323             {
5324               node = _gtk_rbtree_next (tree, node);
5325               if (node != NULL)
5326                 {
5327                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
5328                   done = TRUE;
5329
5330                   /* Sanity Check! */
5331                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
5332                 }
5333               else
5334                 {
5335                   GtkTreeIter parent_iter = iter;
5336                   gboolean has_parent;
5337
5338                   node = tree->parent_node;
5339                   tree = tree->parent_tree;
5340                   if (tree == NULL)
5341                     /* we should go to done to free some memory */
5342                     goto done;
5343                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
5344                                                            &iter,
5345                                                            &parent_iter);
5346                   depth--;
5347
5348                   /* Sanity check */
5349                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
5350                 }
5351             }
5352           while (!done);
5353         }
5354     }
5355   while (y_offset < clip.height);
5356
5357 done:
5358   gtk_tree_view_draw_grid_lines (tree_view, cr, n_visible_columns);
5359
5360   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
5361     gtk_tree_view_paint_rubber_band (tree_view, cr);
5362
5363   if (drag_dest_path)
5364     gtk_tree_path_free (drag_dest_path);
5365
5366   return FALSE;
5367 }
5368
5369 static gboolean
5370 gtk_tree_view_draw (GtkWidget *widget,
5371                     cairo_t   *cr)
5372 {
5373   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5374   GtkWidget   *button;
5375   GtkStyleContext *context;
5376
5377   context = gtk_widget_get_style_context (widget);
5378   gtk_render_background (context, cr,
5379                          0, 0,
5380                          gtk_widget_get_allocated_width (widget),
5381                          gtk_widget_get_allocated_height (widget));
5382
5383   if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
5384     {
5385       GList *tmp_list;
5386
5387       cairo_save (cr);
5388
5389       gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
5390       gtk_tree_view_bin_draw (widget, cr);
5391
5392       cairo_restore (cr);
5393
5394       /* We can't just chain up to Container::draw as it will try to send the
5395        * event to the headers, so we handle propagating it to our children
5396        * (eg. widgets being edited) ourselves.
5397        */
5398       tmp_list = tree_view->priv->children;
5399       while (tmp_list)
5400         {
5401           GtkTreeViewChild *child = tmp_list->data;
5402           tmp_list = tmp_list->next;
5403
5404           gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
5405         }
5406     }
5407
5408   gtk_style_context_save (context);
5409   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_VIEW);
5410
5411   if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
5412     {
5413       GList *list;
5414
5415       for (list = tree_view->priv->columns; list != NULL; list = list->next)
5416         {
5417           GtkTreeViewColumn *column = list->data;
5418
5419           if (column == tree_view->priv->drag_column)
5420             continue;
5421
5422           if (gtk_tree_view_column_get_visible (column))
5423             {
5424               button = gtk_tree_view_column_get_button (column);
5425               gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5426                                             button, cr);
5427             }
5428         }
5429     }
5430
5431   if (tree_view->priv->drag_window &&
5432       gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
5433     {
5434       button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
5435       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5436                                     button, cr);
5437     }
5438
5439   gtk_style_context_restore (context);
5440
5441   return FALSE;
5442 }
5443
5444 enum
5445 {
5446   DROP_HOME,
5447   DROP_RIGHT,
5448   DROP_LEFT,
5449   DROP_END
5450 };
5451
5452 /* returns 0x1 when no column has been found -- yes it's hackish */
5453 static GtkTreeViewColumn *
5454 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5455                                GtkTreeViewColumn *column,
5456                                gint               drop_position)
5457 {
5458   GtkTreeViewColumn *left_column = NULL;
5459   GtkTreeViewColumn *cur_column = NULL;
5460   GList *tmp_list;
5461
5462   if (!gtk_tree_view_column_get_reorderable (column))
5463     return (GtkTreeViewColumn *)0x1;
5464
5465   switch (drop_position)
5466     {
5467       case DROP_HOME:
5468         /* find first column where we can drop */
5469         tmp_list = tree_view->priv->columns;
5470         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5471           return (GtkTreeViewColumn *)0x1;
5472
5473         while (tmp_list)
5474           {
5475             g_assert (tmp_list);
5476
5477             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5478             tmp_list = tmp_list->next;
5479
5480             if (left_column &&
5481                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5482               continue;
5483
5484             if (!tree_view->priv->column_drop_func)
5485               return left_column;
5486
5487             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5488               {
5489                 left_column = cur_column;
5490                 continue;
5491               }
5492
5493             return left_column;
5494           }
5495
5496         if (!tree_view->priv->column_drop_func)
5497           return left_column;
5498
5499         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5500           return left_column;
5501         else
5502           return (GtkTreeViewColumn *)0x1;
5503         break;
5504
5505       case DROP_RIGHT:
5506         /* find first column after column where we can drop */
5507         tmp_list = tree_view->priv->columns;
5508
5509         for (; tmp_list; tmp_list = tmp_list->next)
5510           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5511             break;
5512
5513         if (!tmp_list || !tmp_list->next)
5514           return (GtkTreeViewColumn *)0x1;
5515
5516         tmp_list = tmp_list->next;
5517         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5518         tmp_list = tmp_list->next;
5519
5520         while (tmp_list)
5521           {
5522             g_assert (tmp_list);
5523
5524             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5525             tmp_list = tmp_list->next;
5526
5527             if (left_column &&
5528                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5529               {
5530                 left_column = cur_column;
5531                 if (tmp_list)
5532                   tmp_list = tmp_list->next;
5533                 continue;
5534               }
5535
5536             if (!tree_view->priv->column_drop_func)
5537               return left_column;
5538
5539             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5540               {
5541                 left_column = cur_column;
5542                 continue;
5543               }
5544
5545             return left_column;
5546           }
5547
5548         if (!tree_view->priv->column_drop_func)
5549           return left_column;
5550
5551         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5552           return left_column;
5553         else
5554           return (GtkTreeViewColumn *)0x1;
5555         break;
5556
5557       case DROP_LEFT:
5558         /* find first column before column where we can drop */
5559         tmp_list = tree_view->priv->columns;
5560
5561         for (; tmp_list; tmp_list = tmp_list->next)
5562           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5563             break;
5564
5565         if (!tmp_list || !tmp_list->prev)
5566           return (GtkTreeViewColumn *)0x1;
5567
5568         tmp_list = tmp_list->prev;
5569         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5570         tmp_list = tmp_list->prev;
5571
5572         while (tmp_list)
5573           {
5574             g_assert (tmp_list);
5575
5576             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5577
5578             if (left_column &&
5579                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5580               {
5581                 /*if (!tmp_list->prev)
5582                   return (GtkTreeViewColumn *)0x1;
5583                   */
5584 /*
5585                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5586                 tmp_list = tmp_list->prev->prev;
5587                 continue;*/
5588
5589                 cur_column = left_column;
5590                 if (tmp_list)
5591                   tmp_list = tmp_list->prev;
5592                 continue;
5593               }
5594
5595             if (!tree_view->priv->column_drop_func)
5596               return left_column;
5597
5598             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5599               return left_column;
5600
5601             cur_column = left_column;
5602             tmp_list = tmp_list->prev;
5603           }
5604
5605         if (!tree_view->priv->column_drop_func)
5606           return NULL;
5607
5608         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5609           return NULL;
5610         else
5611           return (GtkTreeViewColumn *)0x1;
5612         break;
5613
5614       case DROP_END:
5615         /* same as DROP_HOME case, but doing it backwards */
5616         tmp_list = g_list_last (tree_view->priv->columns);
5617         cur_column = NULL;
5618
5619         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5620           return (GtkTreeViewColumn *)0x1;
5621
5622         while (tmp_list)
5623           {
5624             g_assert (tmp_list);
5625
5626             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5627
5628             if (left_column &&
5629                 gtk_tree_view_column_get_visible (left_column) == FALSE)
5630               {
5631                 cur_column = left_column;
5632                 tmp_list = tmp_list->prev;
5633               }
5634
5635             if (!tree_view->priv->column_drop_func)
5636               return left_column;
5637
5638             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5639               return left_column;
5640
5641             cur_column = left_column;
5642             tmp_list = tmp_list->prev;
5643           }
5644
5645         if (!tree_view->priv->column_drop_func)
5646           return NULL;
5647
5648         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5649           return NULL;
5650         else
5651           return (GtkTreeViewColumn *)0x1;
5652         break;
5653     }
5654
5655   return (GtkTreeViewColumn *)0x1;
5656 }
5657
5658 static gboolean
5659 gtk_tree_view_key_press (GtkWidget   *widget,
5660                          GdkEventKey *event)
5661 {
5662   GtkTreeView *tree_view = (GtkTreeView *) widget;
5663   GtkWidget   *button;
5664
5665   if (tree_view->priv->rubber_band_status)
5666     {
5667       if (event->keyval == GDK_KEY_Escape)
5668         gtk_tree_view_stop_rubber_band (tree_view);
5669
5670       return TRUE;
5671     }
5672
5673   if (tree_view->priv->in_column_drag)
5674     {
5675       if (event->keyval == GDK_KEY_Escape)
5676         {
5677           tree_view->priv->cur_reorder = NULL;
5678           gtk_tree_view_button_release_drag_column (widget, NULL);
5679         }
5680       return TRUE;
5681     }
5682
5683   if (tree_view->priv->headers_visible)
5684     {
5685       GList *focus_column;
5686       gboolean rtl;
5687
5688       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5689
5690       for (focus_column = tree_view->priv->columns;
5691            focus_column;
5692            focus_column = focus_column->next)
5693         {
5694           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5695
5696           button = gtk_tree_view_column_get_button (column);
5697           if (gtk_widget_has_focus (button))
5698             break;
5699         }
5700
5701       if (focus_column &&
5702           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5703           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5704            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right))
5705         {
5706           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5707           gint column_width;
5708
5709           if (!gtk_tree_view_column_get_resizable (column))
5710             {
5711               gtk_widget_error_bell (widget);
5712               return TRUE;
5713             }
5714
5715           column_width = gtk_tree_view_column_get_width (column);
5716
5717           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5718               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5719             {
5720               column_width = MAX (column_width - 2, 0);
5721             }
5722           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5723                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5724             {
5725               column_width = column_width + 2;
5726             }
5727
5728           gtk_tree_view_modify_column_width (tree_view, column, column_width);
5729           return TRUE;
5730         }
5731
5732       if (focus_column &&
5733           (event->state & GDK_MOD1_MASK) &&
5734           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5735            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right
5736            || event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home
5737            || event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End))
5738         {
5739           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5740
5741           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5742               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5743             {
5744               GtkTreeViewColumn *col;
5745               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5746               if (col != (GtkTreeViewColumn *)0x1)
5747                 gtk_tree_view_move_column_after (tree_view, column, col);
5748               else
5749                 gtk_widget_error_bell (widget);
5750             }
5751           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5752                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5753             {
5754               GtkTreeViewColumn *col;
5755               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5756               if (col != (GtkTreeViewColumn *)0x1)
5757                 gtk_tree_view_move_column_after (tree_view, column, col);
5758               else
5759                 gtk_widget_error_bell (widget);
5760             }
5761           else if (event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home)
5762             {
5763               GtkTreeViewColumn *col;
5764               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5765               if (col != (GtkTreeViewColumn *)0x1)
5766                 gtk_tree_view_move_column_after (tree_view, column, col);
5767               else
5768                 gtk_widget_error_bell (widget);
5769             }
5770           else if (event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
5771             {
5772               GtkTreeViewColumn *col;
5773               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
5774               if (col != (GtkTreeViewColumn *)0x1)
5775                 gtk_tree_view_move_column_after (tree_view, column, col);
5776               else
5777                 gtk_widget_error_bell (widget);
5778             }
5779
5780           return TRUE;
5781         }
5782     }
5783
5784   /* Chain up to the parent class.  It handles the keybindings. */
5785   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5786     return TRUE;
5787
5788   if (tree_view->priv->search_entry_avoid_unhandled_binding)
5789     {
5790       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
5791       return FALSE;
5792     }
5793
5794   /* We pass the event to the search_entry.  If its text changes, then we start
5795    * the typeahead find capabilities. */
5796   if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
5797       && tree_view->priv->enable_search
5798       && !tree_view->priv->search_custom_entry_set)
5799     {
5800       GdkEvent *new_event;
5801       char *old_text;
5802       const char *new_text;
5803       gboolean retval;
5804       GdkScreen *screen;
5805       gboolean text_modified;
5806       gulong popup_menu_id;
5807
5808       gtk_tree_view_ensure_interactive_directory (tree_view);
5809
5810       /* Make a copy of the current text */
5811       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5812       new_event = gdk_event_copy ((GdkEvent *) event);
5813       g_object_unref (((GdkEventKey *) new_event)->window);
5814       ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
5815       gtk_widget_realize (tree_view->priv->search_window);
5816
5817       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5818                                         "popup-menu", G_CALLBACK (gtk_true),
5819                                         NULL);
5820
5821       /* Move the entry off screen */
5822       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5823       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5824                        gdk_screen_get_width (screen) + 1,
5825                        gdk_screen_get_height (screen) + 1);
5826       gtk_widget_show (tree_view->priv->search_window);
5827
5828       /* Send the event to the window.  If the preedit_changed signal is emitted
5829        * during this event, we will set priv->imcontext_changed  */
5830       tree_view->priv->imcontext_changed = FALSE;
5831       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5832       gdk_event_free (new_event);
5833       gtk_widget_hide (tree_view->priv->search_window);
5834
5835       g_signal_handler_disconnect (tree_view->priv->search_entry,
5836                                    popup_menu_id);
5837
5838       /* We check to make sure that the entry tried to handle the text, and that
5839        * the text has changed.
5840        */
5841       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5842       text_modified = strcmp (old_text, new_text) != 0;
5843       g_free (old_text);
5844       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5845           (retval && text_modified))               /* ...or the text was modified */
5846         {
5847           if (gtk_tree_view_real_start_interactive_search (tree_view,
5848                                                            gdk_event_get_device ((GdkEvent *) event),
5849                                                            FALSE))
5850             {
5851               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5852               return TRUE;
5853             }
5854           else
5855             {
5856               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5857               return FALSE;
5858             }
5859         }
5860     }
5861
5862   return FALSE;
5863 }
5864
5865 static gboolean
5866 gtk_tree_view_key_release (GtkWidget   *widget,
5867                            GdkEventKey *event)
5868 {
5869   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5870
5871   if (tree_view->priv->rubber_band_status)
5872     return TRUE;
5873
5874   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5875 }
5876
5877 /* FIXME Is this function necessary? Can I get an enter_notify event
5878  * w/o either an expose event or a mouse motion event?
5879  */
5880 static gboolean
5881 gtk_tree_view_enter_notify (GtkWidget        *widget,
5882                             GdkEventCrossing *event)
5883 {
5884   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5885   GtkRBTree *tree;
5886   GtkRBNode *node;
5887   gint new_y;
5888
5889   /* Sanity check it */
5890   if (event->window != tree_view->priv->bin_window)
5891     return FALSE;
5892
5893   if (tree_view->priv->tree == NULL)
5894     return FALSE;
5895
5896   if (event->mode == GDK_CROSSING_GRAB ||
5897       event->mode == GDK_CROSSING_GTK_GRAB ||
5898       event->mode == GDK_CROSSING_GTK_UNGRAB ||
5899       event->mode == GDK_CROSSING_STATE_CHANGED)
5900     return TRUE;
5901
5902   /* find the node internally */
5903   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5904   if (new_y < 0)
5905     new_y = 0;
5906   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5907
5908   tree_view->priv->event_last_x = event->x;
5909   tree_view->priv->event_last_y = event->y;
5910
5911   if ((tree_view->priv->button_pressed_node == NULL) ||
5912       (tree_view->priv->button_pressed_node == node))
5913     prelight_or_select (tree_view, tree, node, event->x, event->y);
5914
5915   return TRUE;
5916 }
5917
5918 static gboolean
5919 gtk_tree_view_leave_notify (GtkWidget        *widget,
5920                             GdkEventCrossing *event)
5921 {
5922   GtkTreeView *tree_view;
5923
5924   if (event->mode == GDK_CROSSING_GRAB ||
5925       event->mode == GDK_CROSSING_GTK_GRAB ||
5926       event->mode == GDK_CROSSING_GTK_UNGRAB)
5927     return TRUE;
5928
5929   tree_view = GTK_TREE_VIEW (widget);
5930
5931   if (tree_view->priv->prelight_node)
5932     _gtk_tree_view_queue_draw_node (tree_view,
5933                                    tree_view->priv->prelight_tree,
5934                                    tree_view->priv->prelight_node,
5935                                    NULL);
5936
5937   tree_view->priv->event_last_x = -10000;
5938   tree_view->priv->event_last_y = -10000;
5939
5940   prelight_or_select (tree_view,
5941                       NULL, NULL,
5942                       -1000, -1000); /* coords not possibly over an arrow */
5943
5944   return TRUE;
5945 }
5946
5947
5948 static gint
5949 gtk_tree_view_focus_out (GtkWidget     *widget,
5950                          GdkEventFocus *event)
5951 {
5952   GtkTreeView *tree_view;
5953
5954   tree_view = GTK_TREE_VIEW (widget);
5955
5956   gtk_widget_queue_draw (widget);
5957
5958   /* destroy interactive search dialog */
5959   if (tree_view->priv->search_window)
5960     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
5961                                       gdk_event_get_device ((GdkEvent *) event));
5962
5963   return FALSE;
5964 }
5965
5966
5967 /* Incremental Reflow
5968  */
5969
5970 static void
5971 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
5972                                  GtkRBTree   *tree,
5973                                  GtkRBNode   *node)
5974 {
5975   GtkAllocation allocation;
5976   gint y;
5977
5978   y = _gtk_rbtree_node_find_offset (tree, node)
5979     - gtk_adjustment_get_value (tree_view->priv->vadjustment)
5980     + gtk_tree_view_get_effective_header_height (tree_view);
5981
5982   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
5983   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
5984                               0, y,
5985                               allocation.width,
5986                               GTK_RBNODE_GET_HEIGHT (node));
5987 }
5988
5989 static gboolean
5990 node_is_visible (GtkTreeView *tree_view,
5991                  GtkRBTree   *tree,
5992                  GtkRBNode   *node)
5993 {
5994   int y;
5995   int height;
5996
5997   y = _gtk_rbtree_node_find_offset (tree, node);
5998   height = gtk_tree_view_get_row_height (tree_view, node);
5999
6000   if (y >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6001       y + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6002                      + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6003     return TRUE;
6004
6005   return FALSE;
6006 }
6007
6008 /* Returns TRUE if it updated the size
6009  */
6010 static gboolean
6011 validate_row (GtkTreeView *tree_view,
6012               GtkRBTree   *tree,
6013               GtkRBNode   *node,
6014               GtkTreeIter *iter,
6015               GtkTreePath *path)
6016 {
6017   GtkTreeViewColumn *column;
6018   GList *list, *first_column, *last_column;
6019   gint height = 0;
6020   gint horizontal_separator;
6021   gint vertical_separator;
6022   gint depth = gtk_tree_path_get_depth (path);
6023   gboolean retval = FALSE;
6024   gboolean is_separator = FALSE;
6025   gboolean draw_vgrid_lines, draw_hgrid_lines;
6026   gint focus_pad;
6027   gint grid_line_width;
6028   gboolean wide_separators;
6029   gint separator_height;
6030   gint expander_size;
6031
6032   /* double check the row needs validating */
6033   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
6034       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6035     return FALSE;
6036
6037   is_separator = row_is_separator (tree_view, iter, NULL);
6038
6039   gtk_widget_style_get (GTK_WIDGET (tree_view),
6040                         "focus-padding", &focus_pad,
6041                         "horizontal-separator", &horizontal_separator,
6042                         "vertical-separator", &vertical_separator,
6043                         "grid-line-width", &grid_line_width,
6044                         "wide-separators",  &wide_separators,
6045                         "separator-height", &separator_height,
6046                         NULL);
6047
6048   draw_vgrid_lines =
6049     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
6050     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6051   draw_hgrid_lines =
6052     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
6053     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
6054   expander_size = gtk_tree_view_get_expander_size (tree_view);
6055
6056   for (last_column = g_list_last (tree_view->priv->columns);
6057        last_column &&
6058        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (last_column->data)));
6059        last_column = last_column->prev)
6060     ;
6061
6062   for (first_column = g_list_first (tree_view->priv->columns);
6063        first_column &&
6064        !(gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (first_column->data)));
6065        first_column = first_column->next)
6066     ;
6067
6068   for (list = tree_view->priv->columns; list; list = list->next)
6069     {
6070       gint padding = 0;
6071       gint original_width;
6072       gint new_width;
6073       gint row_height;
6074
6075       column = list->data;
6076
6077       if (!gtk_tree_view_column_get_visible (column))
6078         continue;
6079
6080       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) &&
6081           !_gtk_tree_view_column_cell_get_dirty (column))
6082         continue;
6083
6084       original_width = _gtk_tree_view_column_get_requested_width (column);
6085
6086       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
6087                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
6088                                                node->children?TRUE:FALSE);
6089       gtk_tree_view_column_cell_get_size (column,
6090                                           NULL, NULL, NULL,
6091                                           NULL, &row_height);
6092
6093       if (!is_separator)
6094         {
6095           row_height += vertical_separator;
6096           height = MAX (height, row_height);
6097           height = MAX (height, expander_size);
6098         }
6099       else
6100         {
6101           if (wide_separators)
6102             height = separator_height + 2 * focus_pad;
6103           else
6104             height = 2 + 2 * focus_pad;
6105         }
6106
6107       if (gtk_tree_view_is_expander_column (tree_view, column))
6108         {
6109           padding += horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
6110
6111           if (gtk_tree_view_draw_expanders (tree_view))
6112             padding += depth * expander_size;
6113         }
6114       else
6115         padding += horizontal_separator;
6116
6117       if (draw_vgrid_lines)
6118         {
6119           if (list->data == first_column || list->data == last_column)
6120             padding += grid_line_width / 2.0;
6121           else
6122             padding += grid_line_width;
6123         }
6124
6125       /* Update the padding for the column */
6126       _gtk_tree_view_column_push_padding (column, padding);
6127       new_width = _gtk_tree_view_column_get_requested_width (column);
6128
6129       if (new_width > original_width)
6130         retval = TRUE;
6131     }
6132
6133   if (draw_hgrid_lines)
6134     height += grid_line_width;
6135
6136   if (height != GTK_RBNODE_GET_HEIGHT (node))
6137     {
6138       retval = TRUE;
6139       _gtk_rbtree_node_set_height (tree, node, height);
6140     }
6141   _gtk_rbtree_node_mark_valid (tree, node);
6142
6143   return retval;
6144 }
6145
6146
6147 static void
6148 validate_visible_area (GtkTreeView *tree_view)
6149 {
6150   GtkAllocation allocation;
6151   GtkTreePath *path = NULL;
6152   GtkTreePath *above_path = NULL;
6153   GtkTreeIter iter;
6154   GtkRBTree *tree = NULL;
6155   GtkRBNode *node = NULL;
6156   gboolean need_redraw = FALSE;
6157   gboolean size_changed = FALSE;
6158   gint total_height;
6159   gint area_above = 0;
6160   gint area_below = 0;
6161
6162   if (tree_view->priv->tree == NULL)
6163     return;
6164
6165   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
6166       tree_view->priv->scroll_to_path == NULL)
6167     return;
6168
6169   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
6170   total_height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
6171
6172   if (total_height == 0)
6173     return;
6174
6175   /* First, we check to see if we need to scroll anywhere
6176    */
6177   if (tree_view->priv->scroll_to_path)
6178     {
6179       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
6180       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
6181         {
6182           /* we are going to scroll, and will update dy */
6183           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6184           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6185               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6186             {
6187               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6188               if (validate_row (tree_view, tree, node, &iter, path))
6189                 size_changed = TRUE;
6190             }
6191
6192           if (tree_view->priv->scroll_to_use_align)
6193             {
6194               gint height = gtk_tree_view_get_row_height (tree_view, node);
6195               area_above = (total_height - height) *
6196                 tree_view->priv->scroll_to_row_align;
6197               area_below = total_height - area_above - height;
6198               area_above = MAX (area_above, 0);
6199               area_below = MAX (area_below, 0);
6200             }
6201           else
6202             {
6203               /* two cases:
6204                * 1) row not visible
6205                * 2) row visible
6206                */
6207               gint dy;
6208               gint height = gtk_tree_view_get_row_height (tree_view, node);
6209
6210               dy = _gtk_rbtree_node_find_offset (tree, node);
6211
6212               if (dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
6213                   dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6214                                   + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6215                 {
6216                   /* row visible: keep the row at the same position */
6217                   area_above = dy - gtk_adjustment_get_value (tree_view->priv->vadjustment);
6218                   area_below = (gtk_adjustment_get_value (tree_view->priv->vadjustment) +
6219                                 gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6220                                - dy - height;
6221                 }
6222               else
6223                 {
6224                   /* row not visible */
6225                   if (dy >= 0
6226                       && dy + height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6227                     {
6228                       /* row at the beginning -- fixed */
6229                       area_above = dy;
6230                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment)
6231                                    - area_above - height;
6232                     }
6233                   else if (dy >= (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6234                                   gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6235                     {
6236                       /* row at the end -- fixed */
6237                       area_above = dy - (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
6238                                    gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6239                       area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) -
6240                                    area_above - height;
6241
6242                       if (area_below < 0)
6243                         {
6244                           area_above = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - height;
6245                           area_below = 0;
6246                         }
6247                     }
6248                   else
6249                     {
6250                       /* row somewhere in the middle, bring it to the top
6251                        * of the view
6252                        */
6253                       area_above = 0;
6254                       area_below = total_height - height;
6255                     }
6256                 }
6257             }
6258         }
6259       else
6260         /* the scroll to isn't valid; ignore it.
6261          */
6262         {
6263           if (tree_view->priv->scroll_to_path && !path)
6264             {
6265               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6266               tree_view->priv->scroll_to_path = NULL;
6267             }
6268           if (path)
6269             gtk_tree_path_free (path);
6270           path = NULL;
6271         }
6272     }
6273
6274   /* We didn't have a scroll_to set, so we just handle things normally
6275    */
6276   if (path == NULL)
6277     {
6278       gint offset;
6279
6280       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6281                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
6282                                         &tree, &node);
6283       if (node == NULL)
6284         {
6285           /* In this case, nothing has been validated */
6286           path = gtk_tree_path_new_first ();
6287           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6288         }
6289       else
6290         {
6291           path = _gtk_tree_path_new_from_rbtree (tree, node);
6292           total_height += offset;
6293         }
6294
6295       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6296
6297       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6298           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6299         {
6300           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6301           if (validate_row (tree_view, tree, node, &iter, path))
6302             size_changed = TRUE;
6303         }
6304       area_above = 0;
6305       area_below = total_height - gtk_tree_view_get_row_height (tree_view, node);
6306     }
6307
6308   above_path = gtk_tree_path_copy (path);
6309
6310   /* if we do not validate any row above the new top_row, we will make sure
6311    * that the row immediately above top_row has been validated. (if we do not
6312    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
6313    * when invalidated that row's height will be zero. and this will mess up
6314    * scrolling).
6315    */
6316   if (area_above == 0)
6317     {
6318       GtkRBTree *tmptree;
6319       GtkRBNode *tmpnode;
6320
6321       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
6322       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
6323
6324       if (tmpnode)
6325         {
6326           GtkTreePath *tmppath;
6327           GtkTreeIter tmpiter;
6328
6329           tmppath = _gtk_tree_path_new_from_rbtree (tmptree, tmpnode);
6330           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
6331
6332           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
6333               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
6334             {
6335               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
6336               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
6337                 size_changed = TRUE;
6338             }
6339
6340           gtk_tree_path_free (tmppath);
6341         }
6342     }
6343
6344   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
6345    * backwards is much slower then forward, as there is no iter_prev function.
6346    * We go forwards first in case we run out of tree.  Then we go backwards to
6347    * fill out the top.
6348    */
6349   while (node && area_below > 0)
6350     {
6351       if (node->children)
6352         {
6353           GtkTreeIter parent = iter;
6354           gboolean has_child;
6355
6356           tree = node->children;
6357           node = _gtk_rbtree_first (tree);
6358
6359           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
6360                                                     &iter,
6361                                                     &parent);
6362           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
6363           gtk_tree_path_down (path);
6364         }
6365       else
6366         {
6367           gboolean done = FALSE;
6368           do
6369             {
6370               node = _gtk_rbtree_next (tree, node);
6371               if (node != NULL)
6372                 {
6373                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
6374                   done = TRUE;
6375                   gtk_tree_path_next (path);
6376
6377                   /* Sanity Check! */
6378                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
6379                 }
6380               else
6381                 {
6382                   GtkTreeIter parent_iter = iter;
6383                   gboolean has_parent;
6384
6385                   node = tree->parent_node;
6386                   tree = tree->parent_tree;
6387                   if (tree == NULL)
6388                     break;
6389                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
6390                                                            &iter,
6391                                                            &parent_iter);
6392                   gtk_tree_path_up (path);
6393
6394                   /* Sanity check */
6395                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
6396                 }
6397             }
6398           while (!done);
6399         }
6400
6401       if (!node)
6402         break;
6403
6404       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6405           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6406         {
6407           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6408           if (validate_row (tree_view, tree, node, &iter, path))
6409               size_changed = TRUE;
6410         }
6411
6412       area_below -= gtk_tree_view_get_row_height (tree_view, node);
6413     }
6414   gtk_tree_path_free (path);
6415
6416   /* If we ran out of tree, and have extra area_below left, we need to add it
6417    * to area_above */
6418   if (area_below > 0)
6419     area_above += area_below;
6420
6421   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
6422
6423   /* We walk backwards */
6424   while (area_above > 0)
6425     {
6426       _gtk_rbtree_prev_full (tree, node, &tree, &node);
6427
6428       /* Always find the new path in the tree.  We cannot just assume
6429        * a gtk_tree_path_prev() is enough here, as there might be children
6430        * in between this node and the previous sibling node.  If this
6431        * appears to be a performance hotspot in profiles, we can look into
6432        * intrigate logic for keeping path, node and iter in sync like
6433        * we do for forward walks.  (Which will be hard because of the lacking
6434        * iter_prev).
6435        */
6436
6437       if (node == NULL)
6438         break;
6439
6440       gtk_tree_path_free (above_path);
6441       above_path = _gtk_tree_path_new_from_rbtree (tree, node);
6442
6443       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
6444
6445       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6446           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6447         {
6448           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6449           if (validate_row (tree_view, tree, node, &iter, above_path))
6450             size_changed = TRUE;
6451         }
6452       area_above -= gtk_tree_view_get_row_height (tree_view, node);
6453     }
6454
6455   /* if we scrolled to a path, we need to set the dy here,
6456    * and sync the top row accordingly
6457    */
6458   if (tree_view->priv->scroll_to_path)
6459     {
6460       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6461       gtk_tree_view_top_row_to_dy (tree_view);
6462
6463       need_redraw = TRUE;
6464     }
6465   else if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6466     {
6467       /* when we are not scrolling, we should never set dy to something
6468        * else than zero. we update top_row to be in sync with dy = 0.
6469        */
6470       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6471       gtk_tree_view_dy_to_top_row (tree_view);
6472     }
6473   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6474     {
6475       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
6476       gtk_tree_view_dy_to_top_row (tree_view);
6477     }
6478   else
6479     gtk_tree_view_top_row_to_dy (tree_view);
6480
6481   /* update width/height and queue a resize */
6482   if (size_changed)
6483     {
6484       GtkRequisition requisition;
6485
6486       /* We temporarily guess a size, under the assumption that it will be the
6487        * same when we get our next size_allocate.  If we don't do this, we'll be
6488        * in an inconsistent state if we call top_row_to_dy. */
6489
6490       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6491                                      &requisition, NULL);
6492       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6493                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6494       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6495                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6496       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6497     }
6498
6499   if (tree_view->priv->scroll_to_path)
6500     {
6501       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6502       tree_view->priv->scroll_to_path = NULL;
6503     }
6504
6505   if (above_path)
6506     gtk_tree_path_free (above_path);
6507
6508   if (tree_view->priv->scroll_to_column)
6509     {
6510       tree_view->priv->scroll_to_column = NULL;
6511     }
6512   if (need_redraw)
6513     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6514 }
6515
6516 static void
6517 initialize_fixed_height_mode (GtkTreeView *tree_view)
6518 {
6519   if (!tree_view->priv->tree)
6520     return;
6521
6522   if (tree_view->priv->fixed_height < 0)
6523     {
6524       GtkTreeIter iter;
6525       GtkTreePath *path;
6526
6527       GtkRBTree *tree = NULL;
6528       GtkRBNode *node = NULL;
6529
6530       tree = tree_view->priv->tree;
6531       node = tree->root;
6532
6533       path = _gtk_tree_path_new_from_rbtree (tree, node);
6534       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6535
6536       validate_row (tree_view, tree, node, &iter, path);
6537
6538       gtk_tree_path_free (path);
6539
6540       tree_view->priv->fixed_height = gtk_tree_view_get_row_height (tree_view, node);
6541     }
6542
6543    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6544                                  tree_view->priv->fixed_height, TRUE);
6545 }
6546
6547 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6548  * the left-most uninvalidated node.  We then try walking right, validating
6549  * nodes.  Once we find a valid node, we repeat the previous process of finding
6550  * the first invalid node.
6551  */
6552
6553 static gboolean
6554 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6555 {
6556   static gboolean prevent_recursion_hack = FALSE;
6557
6558   GtkRBTree *tree = NULL;
6559   GtkRBNode *node = NULL;
6560   gboolean validated_area = FALSE;
6561   gint retval = TRUE;
6562   GtkTreePath *path = NULL;
6563   GtkTreeIter iter;
6564   GTimer *timer;
6565   gint i = 0;
6566
6567   gint y = -1;
6568   gint prev_height = -1;
6569   gboolean fixed_height = TRUE;
6570
6571   g_assert (tree_view);
6572
6573   /* prevent infinite recursion via get_preferred_width() */
6574   if (prevent_recursion_hack)
6575     return FALSE;
6576
6577   if (tree_view->priv->tree == NULL)
6578       return FALSE;
6579
6580   if (tree_view->priv->fixed_height_mode)
6581     {
6582       if (tree_view->priv->fixed_height < 0)
6583         initialize_fixed_height_mode (tree_view);
6584
6585       return FALSE;
6586     }
6587
6588   timer = g_timer_new ();
6589   g_timer_start (timer);
6590
6591   do
6592     {
6593       gboolean changed = FALSE;
6594
6595       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6596         {
6597           retval = FALSE;
6598           goto done;
6599         }
6600
6601       if (path != NULL)
6602         {
6603           node = _gtk_rbtree_next (tree, node);
6604           if (node != NULL)
6605             {
6606               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6607               gtk_tree_path_next (path);
6608             }
6609           else
6610             {
6611               gtk_tree_path_free (path);
6612               path = NULL;
6613             }
6614         }
6615
6616       if (path == NULL)
6617         {
6618           tree = tree_view->priv->tree;
6619           node = tree_view->priv->tree->root;
6620
6621           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6622
6623           do
6624             {
6625               if (!_gtk_rbtree_is_nil (node->left) &&
6626                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6627                 {
6628                   node = node->left;
6629                 }
6630               else if (!_gtk_rbtree_is_nil (node->right) &&
6631                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6632                 {
6633                   node = node->right;
6634                 }
6635               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6636                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6637                 {
6638                   break;
6639                 }
6640               else if (node->children != NULL)
6641                 {
6642                   tree = node->children;
6643                   node = tree->root;
6644                 }
6645               else
6646                 /* RBTree corruption!  All bad */
6647                 g_assert_not_reached ();
6648             }
6649           while (TRUE);
6650           path = _gtk_tree_path_new_from_rbtree (tree, node);
6651           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6652         }
6653
6654       changed = validate_row (tree_view, tree, node, &iter, path);
6655       validated_area = changed || validated_area;
6656
6657       if (changed)
6658         {
6659           gint offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
6660
6661           if (y == -1 || y > offset)
6662             y = offset;
6663         }
6664
6665       if (!tree_view->priv->fixed_height_check)
6666         {
6667           gint height;
6668
6669           height = gtk_tree_view_get_row_height (tree_view, node);
6670           if (prev_height < 0)
6671             prev_height = height;
6672           else if (prev_height != height)
6673             fixed_height = FALSE;
6674         }
6675
6676       i++;
6677     }
6678   while (g_timer_elapsed (timer, NULL) < GTK_TREE_VIEW_TIME_MS_PER_IDLE / 1000.);
6679
6680   if (!tree_view->priv->fixed_height_check)
6681    {
6682      if (fixed_height)
6683        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6684
6685      tree_view->priv->fixed_height_check = 1;
6686    }
6687
6688  done:
6689   if (validated_area)
6690     {
6691       GtkRequisition requisition;
6692
6693       /* We temporarily guess a size, under the assumption that it will be the
6694        * same when we get our next size_allocate.  If we don't do this, we'll be
6695        * in an inconsistent state when we call top_row_to_dy. */
6696
6697       /* FIXME: This is called from size_request, for some reason it is not infinitely
6698        * recursing, we cannot call gtk_widget_get_preferred_size() here because that's
6699        * not allowed (from inside ->get_preferred_width/height() implementations, one
6700        * should call the vfuncs directly). However what is desired here is the full
6701        * size including any margins and limited by any alignment (i.e. after
6702        * GtkWidget:adjust_size_request() is called).
6703        *
6704        * Currently bypassing this but the real solution is to not update the scroll adjustments
6705        * untill we've recieved an allocation (never update scroll adjustments from size-requests).
6706        */
6707       prevent_recursion_hack = TRUE;
6708       gtk_tree_view_get_preferred_width (GTK_WIDGET (tree_view), &requisition.width, NULL);
6709       gtk_tree_view_get_preferred_height (GTK_WIDGET (tree_view), &requisition.height, NULL);
6710       prevent_recursion_hack = FALSE;
6711
6712       /* If rows above the current position have changed height, this has
6713        * affected the current view and thus needs a redraw.
6714        */
6715       if (y != -1 && y < gtk_adjustment_get_value (tree_view->priv->vadjustment))
6716         gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6717
6718       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6719                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6720       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6721                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6722
6723       if (queue_resize)
6724         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
6725     }
6726
6727   if (path) gtk_tree_path_free (path);
6728   g_timer_destroy (timer);
6729
6730   return retval;
6731 }
6732
6733 static gboolean
6734 validate_rows (GtkTreeView *tree_view)
6735 {
6736   gboolean retval;
6737
6738   retval = do_validate_rows (tree_view, TRUE);
6739
6740   if (! retval && tree_view->priv->validate_rows_timer)
6741     {
6742       g_source_remove (tree_view->priv->validate_rows_timer);
6743       tree_view->priv->validate_rows_timer = 0;
6744     }
6745
6746   return retval;
6747 }
6748
6749 static gboolean
6750 validate_rows_handler (GtkTreeView *tree_view)
6751 {
6752   gboolean retval;
6753
6754   retval = do_validate_rows (tree_view, TRUE);
6755   if (! retval && tree_view->priv->validate_rows_timer)
6756     {
6757       g_source_remove (tree_view->priv->validate_rows_timer);
6758       tree_view->priv->validate_rows_timer = 0;
6759     }
6760
6761   return retval;
6762 }
6763
6764 static gboolean
6765 do_presize_handler (GtkTreeView *tree_view)
6766 {
6767   if (tree_view->priv->mark_rows_col_dirty)
6768     {
6769       if (tree_view->priv->tree)
6770         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6771       tree_view->priv->mark_rows_col_dirty = FALSE;
6772     }
6773   validate_visible_area (tree_view);
6774   tree_view->priv->presize_handler_timer = 0;
6775
6776   if (tree_view->priv->fixed_height_mode)
6777     {
6778       GtkRequisition requisition;
6779
6780       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6781                                      &requisition, NULL);
6782
6783       gtk_adjustment_set_upper (tree_view->priv->hadjustment,
6784                                 MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), requisition.width));
6785       gtk_adjustment_set_upper (tree_view->priv->vadjustment,
6786                                 MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), requisition.height));
6787       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6788     }
6789
6790   return FALSE;
6791 }
6792
6793 static gboolean
6794 presize_handler_callback (gpointer data)
6795 {
6796   do_presize_handler (GTK_TREE_VIEW (data));
6797
6798   return FALSE;
6799 }
6800
6801 static void
6802 install_presize_handler (GtkTreeView *tree_view)
6803 {
6804   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6805     return;
6806
6807   if (! tree_view->priv->presize_handler_timer)
6808     {
6809       tree_view->priv->presize_handler_timer =
6810         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6811     }
6812   if (! tree_view->priv->validate_rows_timer)
6813     {
6814       tree_view->priv->validate_rows_timer =
6815         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6816     }
6817 }
6818
6819 static gboolean
6820 scroll_sync_handler (GtkTreeView *tree_view)
6821 {
6822   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
6823     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6824   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6825     gtk_tree_view_top_row_to_dy (tree_view);
6826   else
6827     gtk_tree_view_dy_to_top_row (tree_view);
6828
6829   tree_view->priv->scroll_sync_timer = 0;
6830
6831   return FALSE;
6832 }
6833
6834 static void
6835 install_scroll_sync_handler (GtkTreeView *tree_view)
6836 {
6837   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6838     return;
6839
6840   if (!tree_view->priv->scroll_sync_timer)
6841     {
6842       tree_view->priv->scroll_sync_timer =
6843         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6844     }
6845 }
6846
6847 static void
6848 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6849                            GtkTreePath *path,
6850                            gint         offset)
6851 {
6852   gtk_tree_row_reference_free (tree_view->priv->top_row);
6853
6854   if (!path)
6855     {
6856       tree_view->priv->top_row = NULL;
6857       tree_view->priv->top_row_dy = 0;
6858     }
6859   else
6860     {
6861       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6862       tree_view->priv->top_row_dy = offset;
6863     }
6864 }
6865
6866 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6867  * it's set to be NULL, and top_row_dy is 0;
6868  */
6869 static void
6870 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6871 {
6872   gint offset;
6873   GtkTreePath *path;
6874   GtkRBTree *tree;
6875   GtkRBNode *node;
6876
6877   if (tree_view->priv->tree == NULL)
6878     {
6879       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6880     }
6881   else
6882     {
6883       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6884                                         tree_view->priv->dy,
6885                                         &tree, &node);
6886
6887       if (tree == NULL)
6888         {
6889           gtk_tree_view_set_top_row (tree_view, NULL, 0);
6890         }
6891       else
6892         {
6893           path = _gtk_tree_path_new_from_rbtree (tree, node);
6894           gtk_tree_view_set_top_row (tree_view, path, offset);
6895           gtk_tree_path_free (path);
6896         }
6897     }
6898 }
6899
6900 static void
6901 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6902 {
6903   GtkTreePath *path;
6904   GtkRBTree *tree;
6905   GtkRBNode *node;
6906   int new_dy;
6907
6908   /* Avoid recursive calls */
6909   if (tree_view->priv->in_top_row_to_dy)
6910     return;
6911
6912   if (tree_view->priv->top_row)
6913     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6914   else
6915     path = NULL;
6916
6917   if (!path)
6918     tree = NULL;
6919   else
6920     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6921
6922   if (path)
6923     gtk_tree_path_free (path);
6924
6925   if (tree == NULL)
6926     {
6927       /* keep dy and set new toprow */
6928       gtk_tree_row_reference_free (tree_view->priv->top_row);
6929       tree_view->priv->top_row = NULL;
6930       tree_view->priv->top_row_dy = 0;
6931       /* DO NOT install the idle handler */
6932       gtk_tree_view_dy_to_top_row (tree_view);
6933       return;
6934     }
6935
6936   if (gtk_tree_view_get_row_height (tree_view, node)
6937       < tree_view->priv->top_row_dy)
6938     {
6939       /* new top row -- do NOT install the idle handler */
6940       gtk_tree_view_dy_to_top_row (tree_view);
6941       return;
6942     }
6943
6944   new_dy = _gtk_rbtree_node_find_offset (tree, node);
6945   new_dy += tree_view->priv->top_row_dy;
6946
6947   if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
6948     new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
6949
6950   new_dy = MAX (0, new_dy);
6951
6952   tree_view->priv->in_top_row_to_dy = TRUE;
6953   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
6954   tree_view->priv->in_top_row_to_dy = FALSE;
6955 }
6956
6957
6958 void
6959 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view,
6960                                             gboolean     install_handler)
6961 {
6962   tree_view->priv->mark_rows_col_dirty = TRUE;
6963
6964   if (install_handler)
6965     install_presize_handler (tree_view);
6966 }
6967
6968 /*
6969  * This function works synchronously (due to the while (validate_rows...)
6970  * loop).
6971  *
6972  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
6973  * here. You now need to check that yourself.
6974  */
6975 void
6976 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
6977                                 GtkTreeViewColumn *column)
6978 {
6979   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6980   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
6981
6982   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
6983
6984   do_presize_handler (tree_view);
6985   while (validate_rows (tree_view));
6986
6987   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6988 }
6989
6990 /* Drag-and-drop */
6991
6992 static void
6993 set_source_row (GdkDragContext *context,
6994                 GtkTreeModel   *model,
6995                 GtkTreePath    *source_row)
6996 {
6997   g_object_set_data_full (G_OBJECT (context),
6998                           I_("gtk-tree-view-source-row"),
6999                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
7000                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
7001 }
7002
7003 static GtkTreePath*
7004 get_source_row (GdkDragContext *context)
7005 {
7006   GtkTreeRowReference *ref =
7007     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
7008
7009   if (ref)
7010     return gtk_tree_row_reference_get_path (ref);
7011   else
7012     return NULL;
7013 }
7014
7015 typedef struct
7016 {
7017   GtkTreeRowReference *dest_row;
7018   guint                path_down_mode   : 1;
7019   guint                empty_view_drop  : 1;
7020   guint                drop_append_mode : 1;
7021 }
7022 DestRow;
7023
7024 static void
7025 dest_row_free (gpointer data)
7026 {
7027   DestRow *dr = (DestRow *)data;
7028
7029   gtk_tree_row_reference_free (dr->dest_row);
7030   g_slice_free (DestRow, dr);
7031 }
7032
7033 static void
7034 set_dest_row (GdkDragContext *context,
7035               GtkTreeModel   *model,
7036               GtkTreePath    *dest_row,
7037               gboolean        path_down_mode,
7038               gboolean        empty_view_drop,
7039               gboolean        drop_append_mode)
7040 {
7041   DestRow *dr;
7042
7043   if (!dest_row)
7044     {
7045       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7046                               NULL, NULL);
7047       return;
7048     }
7049
7050   dr = g_slice_new (DestRow);
7051
7052   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
7053   dr->path_down_mode = path_down_mode != FALSE;
7054   dr->empty_view_drop = empty_view_drop != FALSE;
7055   dr->drop_append_mode = drop_append_mode != FALSE;
7056
7057   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
7058                           dr, (GDestroyNotify) dest_row_free);
7059 }
7060
7061 static GtkTreePath*
7062 get_dest_row (GdkDragContext *context,
7063               gboolean       *path_down_mode)
7064 {
7065   DestRow *dr =
7066     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
7067
7068   if (dr)
7069     {
7070       GtkTreePath *path = NULL;
7071
7072       if (path_down_mode)
7073         *path_down_mode = dr->path_down_mode;
7074
7075       if (dr->dest_row)
7076         path = gtk_tree_row_reference_get_path (dr->dest_row);
7077       else if (dr->empty_view_drop)
7078         path = gtk_tree_path_new_from_indices (0, -1);
7079       else
7080         path = NULL;
7081
7082       if (path && dr->drop_append_mode)
7083         gtk_tree_path_next (path);
7084
7085       return path;
7086     }
7087   else
7088     return NULL;
7089 }
7090
7091 /* Get/set whether drag_motion requested the drag data and
7092  * drag_data_received should thus not actually insert the data,
7093  * since the data doesn't result from a drop.
7094  */
7095 static void
7096 set_status_pending (GdkDragContext *context,
7097                     GdkDragAction   suggested_action)
7098 {
7099   g_object_set_data (G_OBJECT (context),
7100                      I_("gtk-tree-view-status-pending"),
7101                      GINT_TO_POINTER (suggested_action));
7102 }
7103
7104 static GdkDragAction
7105 get_status_pending (GdkDragContext *context)
7106 {
7107   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
7108                                              "gtk-tree-view-status-pending"));
7109 }
7110
7111 static TreeViewDragInfo*
7112 get_info (GtkTreeView *tree_view)
7113 {
7114   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
7115 }
7116
7117 static void
7118 destroy_info (TreeViewDragInfo *di)
7119 {
7120   g_slice_free (TreeViewDragInfo, di);
7121 }
7122
7123 static TreeViewDragInfo*
7124 ensure_info (GtkTreeView *tree_view)
7125 {
7126   TreeViewDragInfo *di;
7127
7128   di = get_info (tree_view);
7129
7130   if (di == NULL)
7131     {
7132       di = g_slice_new0 (TreeViewDragInfo);
7133
7134       g_object_set_data_full (G_OBJECT (tree_view),
7135                               I_("gtk-tree-view-drag-info"),
7136                               di,
7137                               (GDestroyNotify) destroy_info);
7138     }
7139
7140   return di;
7141 }
7142
7143 static void
7144 remove_info (GtkTreeView *tree_view)
7145 {
7146   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
7147 }
7148
7149 #if 0
7150 static gint
7151 drag_scan_timeout (gpointer data)
7152 {
7153   GtkTreeView *tree_view;
7154   gint x, y;
7155   GdkModifierType state;
7156   GtkTreePath *path = NULL;
7157   GtkTreeViewColumn *column = NULL;
7158   GdkRectangle visible_rect;
7159
7160   gdk_threads_enter ();
7161
7162   tree_view = GTK_TREE_VIEW (data);
7163
7164   gdk_window_get_device_position (tree_view->priv->bin_window,
7165                                   gdk_device_manager_get_client_pointer (
7166                                     gdk_display_get_device_manager (
7167                                       gtk_widget_get_display (GTK_WIDGET (tree_view)))),
7168                                   &x, &y, &state);
7169
7170   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
7171
7172   /* See if we are near the edge. */
7173   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
7174       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
7175       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
7176       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
7177     {
7178       gtk_tree_view_get_path_at_pos (tree_view,
7179                                      tree_view->priv->bin_window,
7180                                      x, y,
7181                                      &path,
7182                                      &column,
7183                                      NULL,
7184                                      NULL);
7185
7186       if (path != NULL)
7187         {
7188           gtk_tree_view_scroll_to_cell (tree_view,
7189                                         path,
7190                                         column,
7191                                         TRUE,
7192                                         0.5, 0.5);
7193
7194           gtk_tree_path_free (path);
7195         }
7196     }
7197
7198   gdk_threads_leave ();
7199
7200   return TRUE;
7201 }
7202 #endif /* 0 */
7203
7204 static void
7205 add_scroll_timeout (GtkTreeView *tree_view)
7206 {
7207   if (tree_view->priv->scroll_timeout == 0)
7208     {
7209       tree_view->priv->scroll_timeout =
7210         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
7211     }
7212 }
7213
7214 static void
7215 remove_scroll_timeout (GtkTreeView *tree_view)
7216 {
7217   if (tree_view->priv->scroll_timeout != 0)
7218     {
7219       g_source_remove (tree_view->priv->scroll_timeout);
7220       tree_view->priv->scroll_timeout = 0;
7221     }
7222 }
7223
7224 static gboolean
7225 check_model_dnd (GtkTreeModel *model,
7226                  GType         required_iface,
7227                  const gchar  *signal)
7228 {
7229   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
7230     {
7231       g_warning ("You must override the default '%s' handler "
7232                  "on GtkTreeView when using models that don't support "
7233                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
7234                  "is to connect to '%s' and call "
7235                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
7236                  "the default handler from running. Look at the source code "
7237                  "for the default handler in gtktreeview.c to get an idea what "
7238                  "your handler should do. (gtktreeview.c is in the GTK source "
7239                  "code.) If you're using GTK from a language other than C, "
7240                  "there may be a more natural way to override default handlers, e.g. via derivation.",
7241                  signal, g_type_name (required_iface), signal);
7242       return FALSE;
7243     }
7244   else
7245     return TRUE;
7246 }
7247
7248 static void
7249 remove_open_timeout (GtkTreeView *tree_view)
7250 {
7251   if (tree_view->priv->open_dest_timeout != 0)
7252     {
7253       g_source_remove (tree_view->priv->open_dest_timeout);
7254       tree_view->priv->open_dest_timeout = 0;
7255     }
7256 }
7257
7258
7259 static gint
7260 open_row_timeout (gpointer data)
7261 {
7262   GtkTreeView *tree_view = data;
7263   GtkTreePath *dest_path = NULL;
7264   GtkTreeViewDropPosition pos;
7265   gboolean result = FALSE;
7266
7267   gtk_tree_view_get_drag_dest_row (tree_view,
7268                                    &dest_path,
7269                                    &pos);
7270
7271   if (dest_path &&
7272       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7273        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7274     {
7275       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
7276       tree_view->priv->open_dest_timeout = 0;
7277
7278       gtk_tree_path_free (dest_path);
7279     }
7280   else
7281     {
7282       if (dest_path)
7283         gtk_tree_path_free (dest_path);
7284
7285       result = TRUE;
7286     }
7287
7288   return result;
7289 }
7290
7291 static gboolean
7292 scroll_row_timeout (gpointer data)
7293 {
7294   GtkTreeView *tree_view = data;
7295
7296   gtk_tree_view_vertical_autoscroll (tree_view);
7297
7298   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
7299     gtk_tree_view_update_rubber_band (tree_view);
7300
7301   return TRUE;
7302 }
7303
7304 /* Returns TRUE if event should not be propagated to parent widgets */
7305 static gboolean
7306 set_destination_row (GtkTreeView    *tree_view,
7307                      GdkDragContext *context,
7308                      /* coordinates relative to the widget */
7309                      gint            x,
7310                      gint            y,
7311                      GdkDragAction  *suggested_action,
7312                      GdkAtom        *target)
7313 {
7314   GtkTreePath *path = NULL;
7315   GtkTreeViewDropPosition pos;
7316   GtkTreeViewDropPosition old_pos;
7317   TreeViewDragInfo *di;
7318   GtkWidget *widget;
7319   GtkTreePath *old_dest_path = NULL;
7320   gboolean can_drop = FALSE;
7321
7322   *suggested_action = 0;
7323   *target = GDK_NONE;
7324
7325   widget = GTK_WIDGET (tree_view);
7326
7327   di = get_info (tree_view);
7328
7329   if (di == NULL || y - gtk_tree_view_get_effective_header_height (tree_view) < 0)
7330     {
7331       /* someone unset us as a drag dest, note that if
7332        * we return FALSE drag_leave isn't called
7333        */
7334
7335       gtk_tree_view_set_drag_dest_row (tree_view,
7336                                        NULL,
7337                                        GTK_TREE_VIEW_DROP_BEFORE);
7338
7339       remove_scroll_timeout (GTK_TREE_VIEW (widget));
7340       remove_open_timeout (GTK_TREE_VIEW (widget));
7341
7342       return FALSE; /* no longer a drop site */
7343     }
7344
7345   *target = gtk_drag_dest_find_target (widget, context,
7346                                        gtk_drag_dest_get_target_list (widget));
7347   if (*target == GDK_NONE)
7348     {
7349       return FALSE;
7350     }
7351
7352   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
7353                                           x, y,
7354                                           &path,
7355                                           &pos))
7356     {
7357       gint n_children;
7358       GtkTreeModel *model;
7359
7360       remove_open_timeout (tree_view);
7361
7362       /* the row got dropped on empty space, let's setup a special case
7363        */
7364
7365       if (path)
7366         gtk_tree_path_free (path);
7367
7368       model = gtk_tree_view_get_model (tree_view);
7369
7370       n_children = gtk_tree_model_iter_n_children (model, NULL);
7371       if (n_children)
7372         {
7373           pos = GTK_TREE_VIEW_DROP_AFTER;
7374           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
7375         }
7376       else
7377         {
7378           pos = GTK_TREE_VIEW_DROP_BEFORE;
7379           path = gtk_tree_path_new_from_indices (0, -1);
7380         }
7381
7382       can_drop = TRUE;
7383
7384       goto out;
7385     }
7386
7387   g_assert (path);
7388
7389   /* If we left the current row's "open" zone, unset the timeout for
7390    * opening the row
7391    */
7392   gtk_tree_view_get_drag_dest_row (tree_view,
7393                                    &old_dest_path,
7394                                    &old_pos);
7395
7396   if (old_dest_path &&
7397       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
7398        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7399          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
7400     remove_open_timeout (tree_view);
7401
7402   if (old_dest_path)
7403     gtk_tree_path_free (old_dest_path);
7404
7405   if (TRUE /* FIXME if the location droppable predicate */)
7406     {
7407       can_drop = TRUE;
7408     }
7409
7410 out:
7411   if (can_drop)
7412     {
7413       GtkWidget *source_widget;
7414
7415       *suggested_action = gdk_drag_context_get_suggested_action (context);
7416       source_widget = gtk_drag_get_source_widget (context);
7417
7418       if (source_widget == widget)
7419         {
7420           /* Default to MOVE, unless the user has
7421            * pressed ctrl or shift to affect available actions
7422            */
7423           if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
7424             *suggested_action = GDK_ACTION_MOVE;
7425         }
7426
7427       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7428                                        path, pos);
7429     }
7430   else
7431     {
7432       /* can't drop here */
7433       remove_open_timeout (tree_view);
7434
7435       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7436                                        NULL,
7437                                        GTK_TREE_VIEW_DROP_BEFORE);
7438     }
7439
7440   if (path)
7441     gtk_tree_path_free (path);
7442
7443   return TRUE;
7444 }
7445
7446 static GtkTreePath*
7447 get_logical_dest_row (GtkTreeView *tree_view,
7448                       gboolean    *path_down_mode,
7449                       gboolean    *drop_append_mode)
7450 {
7451   /* adjust path to point to the row the drop goes in front of */
7452   GtkTreePath *path = NULL;
7453   GtkTreeViewDropPosition pos;
7454
7455   g_return_val_if_fail (path_down_mode != NULL, NULL);
7456   g_return_val_if_fail (drop_append_mode != NULL, NULL);
7457
7458   *path_down_mode = FALSE;
7459   *drop_append_mode = 0;
7460
7461   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7462
7463   if (path == NULL)
7464     return NULL;
7465
7466   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
7467     ; /* do nothing */
7468   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
7469            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
7470     *path_down_mode = TRUE;
7471   else
7472     {
7473       GtkTreeIter iter;
7474       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
7475
7476       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
7477
7478       if (!gtk_tree_model_get_iter (model, &iter, path) ||
7479           !gtk_tree_model_iter_next (model, &iter))
7480         *drop_append_mode = 1;
7481       else
7482         {
7483           *drop_append_mode = 0;
7484           gtk_tree_path_next (path);
7485         }
7486     }
7487
7488   return path;
7489 }
7490
7491 static gboolean
7492 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
7493                                         GdkEventMotion   *event)
7494 {
7495   GtkWidget *widget = GTK_WIDGET (tree_view);
7496   GdkDragContext *context;
7497   TreeViewDragInfo *di;
7498   GtkTreePath *path = NULL;
7499   gint button;
7500   gint cell_x, cell_y;
7501   GtkTreeModel *model;
7502   gboolean retval = FALSE;
7503
7504   di = get_info (tree_view);
7505
7506   if (di == NULL || !di->source_set)
7507     goto out;
7508
7509   if (tree_view->priv->pressed_button < 0)
7510     goto out;
7511
7512   if (!gtk_drag_check_threshold (widget,
7513                                  tree_view->priv->press_start_x,
7514                                  tree_view->priv->press_start_y,
7515                                  event->x, event->y))
7516     goto out;
7517
7518   model = gtk_tree_view_get_model (tree_view);
7519
7520   if (model == NULL)
7521     goto out;
7522
7523   button = tree_view->priv->pressed_button;
7524   tree_view->priv->pressed_button = -1;
7525
7526   gtk_tree_view_get_path_at_pos (tree_view,
7527                                  tree_view->priv->press_start_x,
7528                                  tree_view->priv->press_start_y,
7529                                  &path,
7530                                  NULL,
7531                                  &cell_x,
7532                                  &cell_y);
7533
7534   if (path == NULL)
7535     goto out;
7536
7537   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7538       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7539                                            path))
7540     goto out;
7541
7542   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7543     goto out;
7544
7545   /* Now we can begin the drag */
7546
7547   retval = TRUE;
7548
7549   context = gtk_drag_begin (widget,
7550                             gtk_drag_source_get_target_list (widget),
7551                             di->source_actions,
7552                             button,
7553                             (GdkEvent*)event);
7554
7555   set_source_row (context, model, path);
7556
7557  out:
7558   if (path)
7559     gtk_tree_path_free (path);
7560
7561   return retval;
7562 }
7563
7564
7565 static void
7566 gtk_tree_view_drag_begin (GtkWidget      *widget,
7567                           GdkDragContext *context)
7568 {
7569   GtkTreeView *tree_view;
7570   GtkTreePath *path = NULL;
7571   gint cell_x, cell_y;
7572   cairo_surface_t *row_pix;
7573   TreeViewDragInfo *di;
7574
7575   tree_view = GTK_TREE_VIEW (widget);
7576
7577   /* if the user uses a custom DND source impl, we don't set the icon here */
7578   di = get_info (tree_view);
7579
7580   if (di == NULL || !di->source_set)
7581     return;
7582
7583   gtk_tree_view_get_path_at_pos (tree_view,
7584                                  tree_view->priv->press_start_x,
7585                                  tree_view->priv->press_start_y,
7586                                  &path,
7587                                  NULL,
7588                                  &cell_x,
7589                                  &cell_y);
7590
7591   /* If path is NULL, there's nothing we can drag.  For now, we silently
7592    * bail out.  Actually, dragging should not be possible from an empty
7593    * tree view, but there's no way we can cancel that from here.
7594    * Automatically unsetting the tree view as drag source for empty models
7595    * is something that would likely break other people's code ...
7596    */
7597   if (!path)
7598     return;
7599
7600   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7601                                                 path);
7602   cairo_surface_set_device_offset (row_pix,
7603                                    /* the + 1 is for the black border in the icon */
7604                                    - (tree_view->priv->press_start_x + 1),
7605                                    - (cell_y + 1));
7606
7607   gtk_drag_set_icon_surface (context, row_pix);
7608
7609   cairo_surface_destroy (row_pix);
7610   gtk_tree_path_free (path);
7611 }
7612
7613 static void
7614 gtk_tree_view_drag_end (GtkWidget      *widget,
7615                         GdkDragContext *context)
7616 {
7617   /* do nothing */
7618 }
7619
7620 /* Default signal implementations for the drag signals */
7621 static void
7622 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7623                              GdkDragContext   *context,
7624                              GtkSelectionData *selection_data,
7625                              guint             info,
7626                              guint             time)
7627 {
7628   GtkTreeView *tree_view;
7629   GtkTreeModel *model;
7630   TreeViewDragInfo *di;
7631   GtkTreePath *source_row;
7632
7633   tree_view = GTK_TREE_VIEW (widget);
7634
7635   model = gtk_tree_view_get_model (tree_view);
7636
7637   if (model == NULL)
7638     return;
7639
7640   di = get_info (GTK_TREE_VIEW (widget));
7641
7642   if (di == NULL)
7643     return;
7644
7645   source_row = get_source_row (context);
7646
7647   if (source_row == NULL)
7648     return;
7649
7650   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7651    * any model; for DragSource models there are some other targets
7652    * we also support.
7653    */
7654
7655   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7656       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7657                                           source_row,
7658                                           selection_data))
7659     goto done;
7660
7661   /* If drag_data_get does nothing, try providing row data. */
7662   if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7663     {
7664       gtk_tree_set_row_drag_data (selection_data,
7665                                   model,
7666                                   source_row);
7667     }
7668
7669  done:
7670   gtk_tree_path_free (source_row);
7671 }
7672
7673
7674 static void
7675 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7676                                 GdkDragContext *context)
7677 {
7678   TreeViewDragInfo *di;
7679   GtkTreeModel *model;
7680   GtkTreeView *tree_view;
7681   GtkTreePath *source_row;
7682
7683   tree_view = GTK_TREE_VIEW (widget);
7684   model = gtk_tree_view_get_model (tree_view);
7685
7686   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7687     return;
7688
7689   di = get_info (tree_view);
7690
7691   if (di == NULL)
7692     return;
7693
7694   source_row = get_source_row (context);
7695
7696   if (source_row == NULL)
7697     return;
7698
7699   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7700                                          source_row);
7701
7702   gtk_tree_path_free (source_row);
7703
7704   set_source_row (context, NULL, NULL);
7705 }
7706
7707 static void
7708 gtk_tree_view_drag_leave (GtkWidget      *widget,
7709                           GdkDragContext *context,
7710                           guint             time)
7711 {
7712   /* unset any highlight row */
7713   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7714                                    NULL,
7715                                    GTK_TREE_VIEW_DROP_BEFORE);
7716
7717   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7718   remove_open_timeout (GTK_TREE_VIEW (widget));
7719 }
7720
7721
7722 static gboolean
7723 gtk_tree_view_drag_motion (GtkWidget        *widget,
7724                            GdkDragContext   *context,
7725                            /* coordinates relative to the widget */
7726                            gint              x,
7727                            gint              y,
7728                            guint             time)
7729 {
7730   gboolean empty;
7731   GtkTreePath *path = NULL;
7732   GtkTreeViewDropPosition pos;
7733   GtkTreeView *tree_view;
7734   GdkDragAction suggested_action = 0;
7735   GdkAtom target;
7736
7737   tree_view = GTK_TREE_VIEW (widget);
7738
7739   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7740     return FALSE;
7741
7742   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7743
7744   /* we only know this *after* set_desination_row */
7745   empty = tree_view->priv->empty_view_drop;
7746
7747   if (path == NULL && !empty)
7748     {
7749       /* Can't drop here. */
7750       gdk_drag_status (context, 0, time);
7751     }
7752   else
7753     {
7754       if (tree_view->priv->open_dest_timeout == 0 &&
7755           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7756            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7757         {
7758           tree_view->priv->open_dest_timeout =
7759             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7760         }
7761       else
7762         {
7763           add_scroll_timeout (tree_view);
7764         }
7765
7766       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7767         {
7768           /* Request data so we can use the source row when
7769            * determining whether to accept the drop
7770            */
7771           set_status_pending (context, suggested_action);
7772           gtk_drag_get_data (widget, context, target, time);
7773         }
7774       else
7775         {
7776           set_status_pending (context, 0);
7777           gdk_drag_status (context, suggested_action, time);
7778         }
7779     }
7780
7781   if (path)
7782     gtk_tree_path_free (path);
7783
7784   return TRUE;
7785 }
7786
7787
7788 static gboolean
7789 gtk_tree_view_drag_drop (GtkWidget        *widget,
7790                          GdkDragContext   *context,
7791                          /* coordinates relative to the widget */
7792                          gint              x,
7793                          gint              y,
7794                          guint             time)
7795 {
7796   GtkTreeView *tree_view;
7797   GtkTreePath *path;
7798   GdkDragAction suggested_action = 0;
7799   GdkAtom target = GDK_NONE;
7800   TreeViewDragInfo *di;
7801   GtkTreeModel *model;
7802   gboolean path_down_mode;
7803   gboolean drop_append_mode;
7804
7805   tree_view = GTK_TREE_VIEW (widget);
7806
7807   model = gtk_tree_view_get_model (tree_view);
7808
7809   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7810   remove_open_timeout (GTK_TREE_VIEW (widget));
7811
7812   di = get_info (tree_view);
7813
7814   if (di == NULL)
7815     return FALSE;
7816
7817   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7818     return FALSE;
7819
7820   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7821     return FALSE;
7822
7823   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7824
7825   if (target != GDK_NONE && path != NULL)
7826     {
7827       /* in case a motion had requested drag data, change things so we
7828        * treat drag data receives as a drop.
7829        */
7830       set_status_pending (context, 0);
7831       set_dest_row (context, model, path,
7832                     path_down_mode, tree_view->priv->empty_view_drop,
7833                     drop_append_mode);
7834     }
7835
7836   if (path)
7837     gtk_tree_path_free (path);
7838
7839   /* Unset this thing */
7840   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7841                                    NULL,
7842                                    GTK_TREE_VIEW_DROP_BEFORE);
7843
7844   if (target != GDK_NONE)
7845     {
7846       gtk_drag_get_data (widget, context, target, time);
7847       return TRUE;
7848     }
7849   else
7850     return FALSE;
7851 }
7852
7853 static void
7854 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7855                                   GdkDragContext   *context,
7856                                   /* coordinates relative to the widget */
7857                                   gint              x,
7858                                   gint              y,
7859                                   GtkSelectionData *selection_data,
7860                                   guint             info,
7861                                   guint             time)
7862 {
7863   GtkTreePath *path;
7864   TreeViewDragInfo *di;
7865   gboolean accepted = FALSE;
7866   GtkTreeModel *model;
7867   GtkTreeView *tree_view;
7868   GtkTreePath *dest_row;
7869   GdkDragAction suggested_action;
7870   gboolean path_down_mode;
7871   gboolean drop_append_mode;
7872
7873   tree_view = GTK_TREE_VIEW (widget);
7874
7875   model = gtk_tree_view_get_model (tree_view);
7876
7877   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7878     return;
7879
7880   di = get_info (tree_view);
7881
7882   if (di == NULL)
7883     return;
7884
7885   suggested_action = get_status_pending (context);
7886
7887   if (suggested_action)
7888     {
7889       /* We are getting this data due to a request in drag_motion,
7890        * rather than due to a request in drag_drop, so we are just
7891        * supposed to call drag_status, not actually paste in the
7892        * data.
7893        */
7894       path = get_logical_dest_row (tree_view, &path_down_mode,
7895                                    &drop_append_mode);
7896
7897       if (path == NULL)
7898         suggested_action = 0;
7899       else if (path_down_mode)
7900         gtk_tree_path_down (path);
7901
7902       if (suggested_action)
7903         {
7904           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7905                                                      path,
7906                                                      selection_data))
7907             {
7908               if (path_down_mode)
7909                 {
7910                   path_down_mode = FALSE;
7911                   gtk_tree_path_up (path);
7912
7913                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7914                                                              path,
7915                                                              selection_data))
7916                     suggested_action = 0;
7917                 }
7918               else
7919                 suggested_action = 0;
7920             }
7921         }
7922
7923       gdk_drag_status (context, suggested_action, time);
7924
7925       if (path)
7926         gtk_tree_path_free (path);
7927
7928       /* If you can't drop, remove user drop indicator until the next motion */
7929       if (suggested_action == 0)
7930         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7931                                          NULL,
7932                                          GTK_TREE_VIEW_DROP_BEFORE);
7933
7934       return;
7935     }
7936
7937   dest_row = get_dest_row (context, &path_down_mode);
7938
7939   if (dest_row == NULL)
7940     return;
7941
7942   if (gtk_selection_data_get_length (selection_data) >= 0)
7943     {
7944       if (path_down_mode)
7945         {
7946           gtk_tree_path_down (dest_row);
7947           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7948                                                      dest_row, selection_data))
7949             gtk_tree_path_up (dest_row);
7950         }
7951     }
7952
7953   if (gtk_selection_data_get_length (selection_data) >= 0)
7954     {
7955       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
7956                                                  dest_row,
7957                                                  selection_data))
7958         accepted = TRUE;
7959     }
7960
7961   gtk_drag_finish (context,
7962                    accepted,
7963                    (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
7964                    time);
7965
7966   if (gtk_tree_path_get_depth (dest_row) == 1 &&
7967       gtk_tree_path_get_indices (dest_row)[0] == 0 &&
7968       gtk_tree_model_iter_n_children (tree_view->priv->model, NULL) != 0)
7969     {
7970       /* special special case drag to "0", scroll to first item */
7971       if (!tree_view->priv->scroll_to_path)
7972         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
7973     }
7974
7975   gtk_tree_path_free (dest_row);
7976
7977   /* drop dest_row */
7978   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
7979 }
7980
7981
7982
7983 /* GtkContainer Methods
7984  */
7985
7986
7987 static void
7988 gtk_tree_view_remove (GtkContainer *container,
7989                       GtkWidget    *widget)
7990 {
7991   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7992   GtkTreeViewChild *child = NULL;
7993   GList *tmp_list;
7994
7995   tmp_list = tree_view->priv->children;
7996   while (tmp_list)
7997     {
7998       child = tmp_list->data;
7999       if (child->widget == widget)
8000         {
8001           gtk_widget_unparent (widget);
8002
8003           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
8004           g_list_free_1 (tmp_list);
8005           g_slice_free (GtkTreeViewChild, child);
8006           return;
8007         }
8008
8009       tmp_list = tmp_list->next;
8010     }
8011
8012   tmp_list = tree_view->priv->columns;
8013
8014   while (tmp_list)
8015     {
8016       GtkTreeViewColumn *column;
8017       GtkWidget         *button;
8018
8019       column = tmp_list->data;
8020       button = gtk_tree_view_column_get_button (column);
8021
8022       if (button == widget)
8023         {
8024           gtk_widget_unparent (widget);
8025           return;
8026         }
8027       tmp_list = tmp_list->next;
8028     }
8029 }
8030
8031 static void
8032 gtk_tree_view_forall (GtkContainer *container,
8033                       gboolean      include_internals,
8034                       GtkCallback   callback,
8035                       gpointer      callback_data)
8036 {
8037   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8038   GtkTreeViewChild *child = NULL;
8039   GtkTreeViewColumn *column;
8040   GtkWidget *button;
8041   GList *tmp_list;
8042
8043   tmp_list = tree_view->priv->children;
8044   while (tmp_list)
8045     {
8046       child = tmp_list->data;
8047       tmp_list = tmp_list->next;
8048
8049       (* callback) (child->widget, callback_data);
8050     }
8051   if (include_internals == FALSE)
8052     return;
8053
8054   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8055     {
8056       column = tmp_list->data;
8057       button = gtk_tree_view_column_get_button (column);
8058
8059       if (button)
8060         (* callback) (button, callback_data);
8061     }
8062 }
8063
8064 /* Returns TRUE is any of the columns contains a cell that can-focus.
8065  * If this is not the case, a column-spanning focus rectangle will be
8066  * drawn.
8067  */
8068 static gboolean
8069 gtk_tree_view_has_can_focus_cell (GtkTreeView *tree_view)
8070 {
8071   GList *list;
8072
8073   for (list = tree_view->priv->columns; list; list = list->next)
8074     {
8075       GtkTreeViewColumn *column = list->data;
8076
8077       if (!gtk_tree_view_column_get_visible (column))
8078         continue;
8079       if (gtk_cell_area_is_activatable (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column))))
8080         return TRUE;
8081     }
8082
8083   return FALSE;
8084 }
8085
8086 static void
8087 column_sizing_notify (GObject    *object,
8088                       GParamSpec *pspec,
8089                       gpointer    data)
8090 {
8091   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
8092
8093   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
8094     /* disable fixed height mode */
8095     g_object_set (data, "fixed-height-mode", FALSE, NULL);
8096 }
8097
8098 /**
8099  * gtk_tree_view_set_fixed_height_mode:
8100  * @tree_view: a #GtkTreeView
8101  * @enable: %TRUE to enable fixed height mode
8102  *
8103  * Enables or disables the fixed height mode of @tree_view.
8104  * Fixed height mode speeds up #GtkTreeView by assuming that all
8105  * rows have the same height.
8106  * Only enable this option if all rows are the same height and all
8107  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
8108  *
8109  * Since: 2.6
8110  **/
8111 void
8112 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
8113                                      gboolean     enable)
8114 {
8115   GList *l;
8116
8117   enable = enable != FALSE;
8118
8119   if (enable == tree_view->priv->fixed_height_mode)
8120     return;
8121
8122   if (!enable)
8123     {
8124       tree_view->priv->fixed_height_mode = 0;
8125       tree_view->priv->fixed_height = -1;
8126     }
8127   else
8128     {
8129       /* make sure all columns are of type FIXED */
8130       for (l = tree_view->priv->columns; l; l = l->next)
8131         {
8132           GtkTreeViewColumn *c = l->data;
8133
8134           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
8135         }
8136
8137       /* yes, we really have to do this is in a separate loop */
8138       for (l = tree_view->priv->columns; l; l = l->next)
8139         g_signal_connect (l->data, "notify::sizing",
8140                           G_CALLBACK (column_sizing_notify), tree_view);
8141
8142       tree_view->priv->fixed_height_mode = 1;
8143       tree_view->priv->fixed_height = -1;
8144     }
8145
8146   /* force a revalidation */
8147   install_presize_handler (tree_view);
8148
8149   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
8150 }
8151
8152 /**
8153  * gtk_tree_view_get_fixed_height_mode:
8154  * @tree_view: a #GtkTreeView
8155  *
8156  * Returns whether fixed height mode is turned on for @tree_view.
8157  *
8158  * Return value: %TRUE if @tree_view is in fixed height mode
8159  *
8160  * Since: 2.6
8161  **/
8162 gboolean
8163 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
8164 {
8165   return tree_view->priv->fixed_height_mode;
8166 }
8167
8168 /* Returns TRUE if the focus is within the headers, after the focus operation is
8169  * done
8170  */
8171 static gboolean
8172 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
8173                             GtkDirectionType  dir,
8174                             gboolean          clamp_column_visible)
8175 {
8176   GtkTreeViewColumn *column;
8177   GtkWidget *focus_child;
8178   GtkWidget *button;
8179   GList *last_column, *first_column;
8180   GList *tmp_list;
8181   gboolean rtl;
8182
8183   if (! tree_view->priv->headers_visible)
8184     return FALSE;
8185
8186   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
8187
8188   first_column = tree_view->priv->columns;
8189   while (first_column)
8190     {
8191       column = GTK_TREE_VIEW_COLUMN (first_column->data);
8192       button = gtk_tree_view_column_get_button (column);
8193
8194       if (gtk_widget_get_can_focus (button) &&
8195           gtk_tree_view_column_get_visible (column) &&
8196           (gtk_tree_view_column_get_clickable (column) ||
8197            gtk_tree_view_column_get_reorderable (column)))
8198         break;
8199       first_column = first_column->next;
8200     }
8201
8202   /* No headers are visible, or are focusable.  We can't focus in or out.
8203    */
8204   if (first_column == NULL)
8205     return FALSE;
8206
8207   last_column = g_list_last (tree_view->priv->columns);
8208   while (last_column)
8209     {
8210       column = GTK_TREE_VIEW_COLUMN (last_column->data);
8211       button = gtk_tree_view_column_get_button (column);
8212
8213       if (gtk_widget_get_can_focus (button) &&
8214           gtk_tree_view_column_get_visible (column) &&
8215           (gtk_tree_view_column_get_clickable (column) ||
8216            gtk_tree_view_column_get_reorderable (column)))
8217         break;
8218       last_column = last_column->prev;
8219     }
8220
8221
8222   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8223
8224   switch (dir)
8225     {
8226     case GTK_DIR_TAB_BACKWARD:
8227     case GTK_DIR_TAB_FORWARD:
8228     case GTK_DIR_UP:
8229     case GTK_DIR_DOWN:
8230       if (focus_child == NULL)
8231         {
8232           if (tree_view->priv->focus_column != NULL)
8233             button = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8234           else
8235             button = NULL;
8236
8237           if (button && gtk_widget_get_can_focus (button))
8238             focus_child = button;
8239           else
8240             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8241
8242           gtk_widget_grab_focus (focus_child);
8243           break;
8244         }
8245       return FALSE;
8246
8247     case GTK_DIR_LEFT:
8248     case GTK_DIR_RIGHT:
8249       if (focus_child == NULL)
8250         {
8251           if (tree_view->priv->focus_column != NULL)
8252             focus_child = gtk_tree_view_column_get_button (tree_view->priv->focus_column);
8253           else if (dir == GTK_DIR_LEFT)
8254             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (last_column->data));
8255           else
8256             focus_child = gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (first_column->data));
8257
8258           gtk_widget_grab_focus (focus_child);
8259           break;
8260         }
8261
8262       if (gtk_widget_child_focus (focus_child, dir))
8263         {
8264           /* The focus moves inside the button. */
8265           /* This is probably a great example of bad UI */
8266           break;
8267         }
8268
8269       /* We need to move the focus among the row of buttons. */
8270       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8271         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8272           break;
8273
8274       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
8275           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
8276         {
8277           gtk_widget_error_bell (GTK_WIDGET (tree_view));
8278           break;
8279         }
8280
8281       while (tmp_list)
8282         {
8283           GtkTreeViewColumn *column;
8284           GtkWidget         *button;
8285
8286           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
8287             tmp_list = tmp_list->next;
8288           else
8289             tmp_list = tmp_list->prev;
8290
8291           if (tmp_list == NULL)
8292             {
8293               g_warning ("Internal button not found");
8294               break;
8295             }
8296           column = tmp_list->data;
8297           button = gtk_tree_view_column_get_button (column);
8298           if (button &&
8299               gtk_tree_view_column_get_visible (column) &&
8300               gtk_widget_get_can_focus (button))
8301             {
8302               focus_child = button;
8303               gtk_widget_grab_focus (button);
8304               break;
8305             }
8306         }
8307       break;
8308     default:
8309       g_assert_not_reached ();
8310       break;
8311     }
8312
8313   /* if focus child is non-null, we assume it's been set to the current focus child
8314    */
8315   if (focus_child)
8316     {
8317       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
8318         if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (tmp_list->data)) == focus_child)
8319           {
8320             _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (tmp_list->data));
8321             break;
8322           }
8323
8324       if (clamp_column_visible)
8325         {
8326           gtk_tree_view_clamp_column_visible (tree_view,
8327                                               tree_view->priv->focus_column,
8328                                               FALSE);
8329         }
8330     }
8331
8332   return (focus_child != NULL);
8333 }
8334
8335 /* This function returns in 'path' the first focusable path, if the given path
8336  * is already focusable, it's the returned one.
8337  */
8338 static gboolean
8339 search_first_focusable_path (GtkTreeView  *tree_view,
8340                              GtkTreePath **path,
8341                              gboolean      search_forward,
8342                              GtkRBTree   **new_tree,
8343                              GtkRBNode   **new_node)
8344 {
8345   GtkRBTree *tree = NULL;
8346   GtkRBNode *node = NULL;
8347
8348   if (!path || !*path)
8349     return FALSE;
8350
8351   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
8352
8353   if (!tree || !node)
8354     return FALSE;
8355
8356   while (node && row_is_separator (tree_view, NULL, *path))
8357     {
8358       if (search_forward)
8359         _gtk_rbtree_next_full (tree, node, &tree, &node);
8360       else
8361         _gtk_rbtree_prev_full (tree, node, &tree, &node);
8362
8363       if (*path)
8364         gtk_tree_path_free (*path);
8365
8366       if (node)
8367         *path = _gtk_tree_path_new_from_rbtree (tree, node);
8368       else
8369         *path = NULL;
8370     }
8371
8372   if (new_tree)
8373     *new_tree = tree;
8374
8375   if (new_node)
8376     *new_node = node;
8377
8378   return (*path != NULL);
8379 }
8380
8381 static gint
8382 gtk_tree_view_focus (GtkWidget        *widget,
8383                      GtkDirectionType  direction)
8384 {
8385   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8386   GtkContainer *container = GTK_CONTAINER (widget);
8387   GtkWidget *focus_child;
8388
8389   if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
8390     return FALSE;
8391
8392   focus_child = gtk_container_get_focus_child (container);
8393
8394   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
8395   /* Case 1.  Headers currently have focus. */
8396   if (focus_child)
8397     {
8398       switch (direction)
8399         {
8400         case GTK_DIR_LEFT:
8401         case GTK_DIR_RIGHT:
8402           gtk_tree_view_header_focus (tree_view, direction, TRUE);
8403           return TRUE;
8404         case GTK_DIR_TAB_BACKWARD:
8405         case GTK_DIR_UP:
8406           return FALSE;
8407         case GTK_DIR_TAB_FORWARD:
8408         case GTK_DIR_DOWN:
8409           gtk_widget_grab_focus (widget);
8410           return TRUE;
8411         default:
8412           g_assert_not_reached ();
8413           return FALSE;
8414         }
8415     }
8416
8417   /* Case 2. We don't have focus at all. */
8418   if (!gtk_widget_has_focus (widget))
8419     {
8420       gtk_widget_grab_focus (widget);
8421       return TRUE;
8422     }
8423
8424   /* Case 3. We have focus already. */
8425   if (direction == GTK_DIR_TAB_BACKWARD)
8426     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
8427   else if (direction == GTK_DIR_TAB_FORWARD)
8428     return FALSE;
8429
8430   /* Other directions caught by the keybindings */
8431   gtk_widget_grab_focus (widget);
8432   return TRUE;
8433 }
8434
8435 static void
8436 gtk_tree_view_grab_focus (GtkWidget *widget)
8437 {
8438   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
8439
8440   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
8441 }
8442
8443 static void
8444 gtk_tree_view_style_updated (GtkWidget *widget)
8445 {
8446   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8447   GList *list;
8448   GtkTreeViewColumn *column;
8449   GtkStyleContext *style_context;
8450   const GtkBitmask *changes;
8451
8452   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->style_updated (widget);
8453
8454   if (gtk_widget_get_realized (widget))
8455     {
8456       gtk_tree_view_ensure_background (tree_view);
8457
8458       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
8459       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
8460     }
8461
8462   style_context = gtk_widget_get_style_context (widget);
8463   changes = _gtk_style_context_get_changes (style_context);
8464   if (changes == NULL || _gtk_css_style_property_changes_affect_size (changes))
8465     {
8466       for (list = tree_view->priv->columns; list; list = list->next)
8467         {
8468           column = list->data;
8469           _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8470         }
8471
8472       tree_view->priv->fixed_height = -1;
8473       _gtk_rbtree_mark_invalid (tree_view->priv->tree);
8474     }
8475 }
8476
8477
8478 static void
8479 gtk_tree_view_set_focus_child (GtkContainer *container,
8480                                GtkWidget    *child)
8481 {
8482   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8483   GList *list;
8484
8485   for (list = tree_view->priv->columns; list; list = list->next)
8486     {
8487       if (gtk_tree_view_column_get_button (GTK_TREE_VIEW_COLUMN (list->data)) == child)
8488         {
8489           _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
8490           break;
8491         }
8492     }
8493
8494   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
8495 }
8496
8497 static GtkWidgetPath *
8498 gtk_tree_view_get_path_for_child (GtkContainer *container,
8499                                   GtkWidget    *child)
8500 {
8501   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8502   GtkWidgetPath *path;
8503   gboolean rtl;
8504   GList *list, *visible_columns = NULL;
8505   gint n_col = 0;
8506
8507   path = GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->get_path_for_child (container, child);
8508   rtl = (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL);
8509
8510   for (list = tree_view->priv->columns; list; list = list->next)
8511     {
8512       GtkTreeViewColumn *column = list->data;
8513
8514       if (gtk_tree_view_column_get_visible (column))
8515         visible_columns = g_list_prepend (visible_columns, column);
8516     }
8517
8518   if (!rtl)
8519     visible_columns = g_list_reverse (visible_columns);
8520
8521   for (list = visible_columns; list != NULL; list = list->next)
8522     {
8523       GtkTreeViewColumn *column = list->data;
8524       GtkRegionFlags flags = 0;
8525
8526       n_col++;
8527
8528       if (gtk_tree_view_column_get_widget (column) != child &&
8529           gtk_tree_view_column_get_button (column) != child)
8530         continue;
8531
8532       if ((n_col % 2) == 0)
8533         flags |= GTK_REGION_EVEN;
8534       else
8535         flags |= GTK_REGION_ODD;
8536
8537       if (n_col == 1)
8538         flags |= GTK_REGION_FIRST;
8539
8540       if (!list->next)
8541         flags |= GTK_REGION_LAST;
8542
8543       gtk_widget_path_iter_add_region (path, gtk_widget_path_length (path) - 2, GTK_STYLE_REGION_COLUMN_HEADER, flags);
8544       break;
8545     }
8546   g_list_free (visible_columns);
8547
8548   return path;
8549 }
8550
8551 static gboolean
8552 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8553                                 GtkMovementStep    step,
8554                                 gint               count)
8555 {
8556   GdkModifierType state;
8557
8558   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8559   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8560                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8561                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8562                         step == GTK_MOVEMENT_PAGES ||
8563                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8564
8565   if (tree_view->priv->tree == NULL)
8566     return FALSE;
8567   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8568     return FALSE;
8569
8570   gtk_tree_view_stop_editing (tree_view, FALSE);
8571   tree_view->priv->draw_keyfocus = TRUE;
8572   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8573
8574   if (gtk_get_current_event_state (&state))
8575     {
8576       GdkModifierType extend_mod_mask;
8577       GdkModifierType modify_mod_mask;
8578
8579       extend_mod_mask =
8580         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8581                                       GDK_MODIFIER_INTENT_EXTEND_SELECTION);
8582
8583       modify_mod_mask =
8584         gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
8585                                       GDK_MODIFIER_INTENT_MODIFY_SELECTION);
8586
8587       if ((state & modify_mod_mask) == modify_mod_mask)
8588         tree_view->priv->modify_selection_pressed = TRUE;
8589       if ((state & extend_mod_mask) == extend_mod_mask)
8590         tree_view->priv->extend_selection_pressed = TRUE;
8591     }
8592   /* else we assume not pressed */
8593
8594   switch (step)
8595     {
8596       /* currently we make no distinction.  When we go bi-di, we need to */
8597     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8598     case GTK_MOVEMENT_VISUAL_POSITIONS:
8599       gtk_tree_view_move_cursor_left_right (tree_view, count);
8600       break;
8601     case GTK_MOVEMENT_DISPLAY_LINES:
8602       gtk_tree_view_move_cursor_up_down (tree_view, count);
8603       break;
8604     case GTK_MOVEMENT_PAGES:
8605       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8606       break;
8607     case GTK_MOVEMENT_BUFFER_ENDS:
8608       gtk_tree_view_move_cursor_start_end (tree_view, count);
8609       break;
8610     default:
8611       g_assert_not_reached ();
8612     }
8613
8614   tree_view->priv->modify_selection_pressed = FALSE;
8615   tree_view->priv->extend_selection_pressed = FALSE;
8616
8617   return TRUE;
8618 }
8619
8620 static void
8621 gtk_tree_view_put (GtkTreeView *tree_view,
8622                    GtkWidget   *child_widget,
8623                    /* in bin_window coordinates */
8624                    gint         x,
8625                    gint         y,
8626                    gint         width,
8627                    gint         height)
8628 {
8629   GtkTreeViewChild *child;
8630
8631   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8632   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8633
8634   child = g_slice_new (GtkTreeViewChild);
8635
8636   child->widget = child_widget;
8637   child->x = x;
8638   child->y = y;
8639   child->width = width;
8640   child->height = height;
8641
8642   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8643
8644   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8645     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8646
8647   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8648 }
8649
8650 void
8651 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8652                                   GtkWidget   *widget,
8653                                   /* in tree coordinates */
8654                                   gint         x,
8655                                   gint         y,
8656                                   gint         width,
8657                                   gint         height)
8658 {
8659   GtkTreeViewChild *child = NULL;
8660   GList *list;
8661   GdkRectangle allocation;
8662
8663   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8664   g_return_if_fail (GTK_IS_WIDGET (widget));
8665
8666   for (list = tree_view->priv->children; list; list = list->next)
8667     {
8668       if (((GtkTreeViewChild *)list->data)->widget == widget)
8669         {
8670           child = list->data;
8671           break;
8672         }
8673     }
8674   if (child == NULL)
8675     return;
8676
8677   allocation.x = child->x = x;
8678   allocation.y = child->y = y;
8679   allocation.width = child->width = width;
8680   allocation.height = child->height = height;
8681
8682   if (gtk_widget_get_realized (widget))
8683     gtk_widget_size_allocate (widget, &allocation);
8684 }
8685
8686
8687 /* TreeModel Callbacks
8688  */
8689
8690 static void
8691 gtk_tree_view_row_changed (GtkTreeModel *model,
8692                            GtkTreePath  *path,
8693                            GtkTreeIter  *iter,
8694                            gpointer      data)
8695 {
8696   GtkTreeView *tree_view = (GtkTreeView *)data;
8697   GtkRBTree *tree;
8698   GtkRBNode *node;
8699   gboolean free_path = FALSE;
8700   GList *list;
8701   GtkTreePath *cursor_path;
8702
8703   g_return_if_fail (path != NULL || iter != NULL);
8704
8705   if (tree_view->priv->cursor_node != NULL)
8706     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
8707                                                   tree_view->priv->cursor_node);
8708   else
8709     cursor_path = NULL;
8710
8711   if (tree_view->priv->edited_column &&
8712       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8713     gtk_tree_view_stop_editing (tree_view, TRUE);
8714
8715   if (cursor_path != NULL)
8716     gtk_tree_path_free (cursor_path);
8717
8718   if (path == NULL)
8719     {
8720       path = gtk_tree_model_get_path (model, iter);
8721       free_path = TRUE;
8722     }
8723   else if (iter == NULL)
8724     gtk_tree_model_get_iter (model, iter, path);
8725
8726   if (_gtk_tree_view_find_node (tree_view,
8727                                 path,
8728                                 &tree,
8729                                 &node))
8730     /* We aren't actually showing the node */
8731     goto done;
8732
8733   if (tree == NULL)
8734     goto done;
8735
8736   _gtk_tree_view_accessible_changed (tree_view, tree, node);
8737
8738   if (tree_view->priv->fixed_height_mode
8739       && tree_view->priv->fixed_height >= 0)
8740     {
8741       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8742       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8743         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8744     }
8745   else
8746     {
8747       _gtk_rbtree_node_mark_invalid (tree, node);
8748       for (list = tree_view->priv->columns; list; list = list->next)
8749         {
8750           GtkTreeViewColumn *column;
8751
8752           column = list->data;
8753           if (!gtk_tree_view_column_get_visible (column))
8754             continue;
8755
8756           if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8757             {
8758               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8759             }
8760         }
8761     }
8762
8763  done:
8764   if (!tree_view->priv->fixed_height_mode &&
8765       gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8766     install_presize_handler (tree_view);
8767   if (free_path)
8768     gtk_tree_path_free (path);
8769 }
8770
8771 static void
8772 gtk_tree_view_row_inserted (GtkTreeModel *model,
8773                             GtkTreePath  *path,
8774                             GtkTreeIter  *iter,
8775                             gpointer      data)
8776 {
8777   GtkTreeView *tree_view = (GtkTreeView *) data;
8778   gint *indices;
8779   GtkRBTree *tree;
8780   GtkRBNode *tmpnode = NULL;
8781   gint depth;
8782   gint i = 0;
8783   gint height;
8784   gboolean free_path = FALSE;
8785   gboolean node_visible = TRUE;
8786
8787   g_return_if_fail (path != NULL || iter != NULL);
8788
8789   if (tree_view->priv->fixed_height_mode
8790       && tree_view->priv->fixed_height >= 0)
8791     height = tree_view->priv->fixed_height;
8792   else
8793     height = 0;
8794
8795   if (path == NULL)
8796     {
8797       path = gtk_tree_model_get_path (model, iter);
8798       free_path = TRUE;
8799     }
8800   else if (iter == NULL)
8801     gtk_tree_model_get_iter (model, iter, path);
8802
8803   if (tree_view->priv->tree == NULL)
8804     tree_view->priv->tree = _gtk_rbtree_new ();
8805
8806   tree = tree_view->priv->tree;
8807
8808   /* Update all row-references */
8809   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8810   depth = gtk_tree_path_get_depth (path);
8811   indices = gtk_tree_path_get_indices (path);
8812
8813   /* First, find the parent tree */
8814   while (i < depth - 1)
8815     {
8816       if (tree == NULL)
8817         {
8818           /* We aren't showing the node */
8819           node_visible = FALSE;
8820           goto done;
8821         }
8822
8823       tmpnode = _gtk_rbtree_find_count (tree, indices[i] + 1);
8824       if (tmpnode == NULL)
8825         {
8826           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8827                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8828                      "before the parent was inserted.");
8829           goto done;
8830         }
8831       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8832         {
8833           /* FIXME enforce correct behavior on model, probably */
8834           /* In theory, the model should have emitted has_child_toggled here.  We
8835            * try to catch it anyway, just to be safe, in case the model hasn't.
8836            */
8837           GtkTreePath *tmppath = _gtk_tree_path_new_from_rbtree (tree, tmpnode);
8838           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8839           gtk_tree_path_free (tmppath);
8840           goto done;
8841         }
8842
8843       tree = tmpnode->children;
8844       i++;
8845     }
8846
8847   if (tree == NULL)
8848     {
8849       node_visible = FALSE;
8850       goto done;
8851     }
8852
8853   /* ref the node */
8854   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8855   if (indices[depth - 1] == 0)
8856     {
8857       tmpnode = _gtk_rbtree_find_count (tree, 1);
8858       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8859     }
8860   else
8861     {
8862       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8863       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8864     }
8865
8866   _gtk_tree_view_accessible_add (tree_view, tree, tmpnode);
8867
8868  done:
8869   if (height > 0)
8870     {
8871       if (tree)
8872         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8873
8874       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8875         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8876       else
8877         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8878     }
8879   else
8880     install_presize_handler (tree_view);
8881   if (free_path)
8882     gtk_tree_path_free (path);
8883 }
8884
8885 static void
8886 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8887                                      GtkTreePath  *path,
8888                                      GtkTreeIter  *iter,
8889                                      gpointer      data)
8890 {
8891   GtkTreeView *tree_view = (GtkTreeView *)data;
8892   GtkTreeIter real_iter;
8893   gboolean has_child;
8894   GtkRBTree *tree;
8895   GtkRBNode *node;
8896   gboolean free_path = FALSE;
8897
8898   g_return_if_fail (path != NULL || iter != NULL);
8899
8900   if (iter)
8901     real_iter = *iter;
8902
8903   if (path == NULL)
8904     {
8905       path = gtk_tree_model_get_path (model, iter);
8906       free_path = TRUE;
8907     }
8908   else if (iter == NULL)
8909     gtk_tree_model_get_iter (model, &real_iter, path);
8910
8911   if (_gtk_tree_view_find_node (tree_view,
8912                                 path,
8913                                 &tree,
8914                                 &node))
8915     /* We aren't actually showing the node */
8916     goto done;
8917
8918   if (tree == NULL)
8919     goto done;
8920
8921   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8922   /* Sanity check.
8923    */
8924   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8925     goto done;
8926
8927   if (has_child)
8928     {
8929       GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8930       _gtk_tree_view_accessible_add_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8931     }
8932   else
8933     {
8934       GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8935       _gtk_tree_view_accessible_remove_state (tree_view, tree, node, GTK_CELL_RENDERER_EXPANDABLE);
8936     }
8937
8938   if (has_child && tree_view->priv->is_list)
8939     {
8940       tree_view->priv->is_list = FALSE;
8941       if (tree_view->priv->show_expanders)
8942         {
8943           GList *list;
8944
8945           for (list = tree_view->priv->columns; list; list = list->next)
8946             if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
8947               {
8948                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8949                 break;
8950               }
8951         }
8952       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8953     }
8954   else
8955     {
8956       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8957     }
8958
8959  done:
8960   if (free_path)
8961     gtk_tree_path_free (path);
8962 }
8963
8964 static void
8965 count_children_helper (GtkRBTree *tree,
8966                        GtkRBNode *node,
8967                        gpointer   data)
8968 {
8969   if (node->children)
8970     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8971   (*((gint *)data))++;
8972 }
8973
8974 static void
8975 check_selection_helper (GtkRBTree *tree,
8976                         GtkRBNode *node,
8977                         gpointer   data)
8978 {
8979   gint *value = (gint *)data;
8980
8981   *value |= GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8982
8983   if (node->children && !*value)
8984     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8985 }
8986
8987 static void
8988 gtk_tree_view_row_deleted (GtkTreeModel *model,
8989                            GtkTreePath  *path,
8990                            gpointer      data)
8991 {
8992   GtkTreeView *tree_view = (GtkTreeView *)data;
8993   GtkRBTree *tree;
8994   GtkRBNode *node;
8995   GList *list;
8996   gboolean selection_changed = FALSE, cursor_changed = FALSE;
8997   GtkRBTree *cursor_tree = NULL;
8998   GtkRBNode *cursor_node = NULL;
8999
9000   g_return_if_fail (path != NULL);
9001
9002   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
9003
9004   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
9005     return;
9006
9007   if (tree == NULL)
9008     return;
9009
9010   /* check if the selection has been changed */
9011   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
9012                         check_selection_helper, &selection_changed);
9013
9014   for (list = tree_view->priv->columns; list; list = list->next)
9015     if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)) &&
9016         gtk_tree_view_column_get_sizing (GTK_TREE_VIEW_COLUMN (list->data)) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
9017       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
9018
9019   /* Ensure we don't have a dangling pointer to a dead node */
9020   ensure_unprelighted (tree_view);
9021
9022   /* Cancel editting if we've started */
9023   gtk_tree_view_stop_editing (tree_view, TRUE);
9024
9025   /* If the cursor row got deleted, move the cursor to the next row */
9026   if (tree_view->priv->cursor_node &&
9027       (tree_view->priv->cursor_node == node ||
9028        (node->children && (tree_view->priv->cursor_tree == node->children ||
9029                            _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree)))))
9030     {
9031       GtkTreePath *cursor_path;
9032
9033       cursor_tree = tree;
9034       cursor_node = _gtk_rbtree_next (tree, node);
9035       /* find the first node that is not going to be deleted */
9036       while (cursor_node == NULL && cursor_tree->parent_tree)
9037         {
9038           cursor_node = _gtk_rbtree_next (cursor_tree->parent_tree,
9039                                           cursor_tree->parent_node);
9040           cursor_tree = cursor_tree->parent_tree;
9041         }
9042
9043       if (cursor_node != NULL)
9044         cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9045       else
9046         cursor_path = NULL;
9047
9048       if (cursor_path == NULL ||
9049           ! search_first_focusable_path (tree_view, &cursor_path, TRUE,
9050                                          &cursor_tree, &cursor_node))
9051         {
9052           /* It looks like we reached the end of the view without finding
9053            * a focusable row.  We will step backwards to find the last
9054            * focusable row.
9055            */
9056           _gtk_rbtree_prev_full (tree, node, &cursor_tree, &cursor_node);
9057           if (cursor_node)
9058             {
9059               cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9060               if (! search_first_focusable_path (tree_view, &cursor_path, FALSE,
9061                                                  &cursor_tree, &cursor_node))
9062                 cursor_node = NULL;
9063               gtk_tree_path_free (cursor_path);
9064             }
9065         }
9066       else if (cursor_path)
9067         gtk_tree_path_free (cursor_path);
9068
9069       cursor_changed = TRUE;
9070     }
9071
9072   if (tree_view->priv->destroy_count_func)
9073     {
9074       gint child_count = 0;
9075       if (node->children)
9076         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
9077       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
9078     }
9079
9080   if (tree->root->count == 1)
9081     {
9082       if (tree_view->priv->tree == tree)
9083         tree_view->priv->tree = NULL;
9084
9085       _gtk_tree_view_accessible_remove_state (tree_view,
9086                                               tree->parent_tree, tree->parent_node,
9087                                               GTK_CELL_RENDERER_EXPANDED);
9088       _gtk_tree_view_accessible_remove (tree_view, tree, NULL);
9089       _gtk_rbtree_remove (tree);
9090     }
9091   else
9092     {
9093       _gtk_tree_view_accessible_remove (tree_view, tree, node);
9094       _gtk_rbtree_remove_node (tree, node);
9095     }
9096
9097   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
9098     {
9099       gtk_tree_row_reference_free (tree_view->priv->top_row);
9100       tree_view->priv->top_row = NULL;
9101     }
9102
9103   install_scroll_sync_handler (tree_view);
9104
9105   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9106
9107   if (cursor_changed)
9108     {
9109       if (cursor_node)
9110         {
9111           GtkTreePath *cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
9112           gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CURSOR_INVALID);
9113           gtk_tree_path_free (cursor_path);
9114         }
9115       else
9116         gtk_tree_view_real_set_cursor (tree_view, NULL, CLEAR_AND_SELECT | CURSOR_INVALID);
9117     }
9118   if (selection_changed)
9119     g_signal_emit_by_name (tree_view->priv->selection, "changed");
9120 }
9121
9122 static void
9123 gtk_tree_view_rows_reordered (GtkTreeModel *model,
9124                               GtkTreePath  *parent,
9125                               GtkTreeIter  *iter,
9126                               gint         *new_order,
9127                               gpointer      data)
9128 {
9129   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
9130   GtkRBTree *tree;
9131   GtkRBNode *node;
9132   gint len;
9133
9134   len = gtk_tree_model_iter_n_children (model, iter);
9135
9136   if (len < 2)
9137     return;
9138
9139   gtk_tree_row_reference_reordered (G_OBJECT (data),
9140                                     parent,
9141                                     iter,
9142                                     new_order);
9143
9144   if (_gtk_tree_view_find_node (tree_view,
9145                                 parent,
9146                                 &tree,
9147                                 &node))
9148     return;
9149
9150   /* We need to special case the parent path */
9151   if (tree == NULL)
9152     tree = tree_view->priv->tree;
9153   else
9154     tree = node->children;
9155
9156   if (tree == NULL)
9157     return;
9158
9159   if (tree_view->priv->edited_column)
9160     gtk_tree_view_stop_editing (tree_view, TRUE);
9161
9162   /* we need to be unprelighted */
9163   ensure_unprelighted (tree_view);
9164
9165   _gtk_rbtree_reorder (tree, new_order, len);
9166
9167   _gtk_tree_view_accessible_reorder (tree_view);
9168
9169   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
9170
9171   gtk_tree_view_dy_to_top_row (tree_view);
9172 }
9173
9174
9175 /* Internal tree functions
9176  */
9177
9178
9179 static void
9180 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
9181                                      GtkRBTree         *tree,
9182                                      GtkTreeViewColumn *column,
9183                                      gint              *x1,
9184                                      gint              *x2)
9185 {
9186   GtkTreeViewColumn *tmp_column = NULL;
9187   gint total_width;
9188   GList *list;
9189   gboolean rtl;
9190
9191   if (x1)
9192     *x1 = 0;
9193
9194   if (x2)
9195     *x2 = 0;
9196
9197   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9198
9199   total_width = 0;
9200   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9201        list;
9202        list = (rtl ? list->prev : list->next))
9203     {
9204       tmp_column = list->data;
9205
9206       if (tmp_column == column)
9207         break;
9208
9209       if (gtk_tree_view_column_get_visible (tmp_column))
9210         total_width += gtk_tree_view_column_get_width (tmp_column);
9211     }
9212
9213   if (tmp_column != column)
9214     {
9215       g_warning (G_STRLOC": passed-in column isn't in the tree");
9216       return;
9217     }
9218
9219   if (x1)
9220     *x1 = total_width;
9221
9222   if (x2)
9223     {
9224       if (gtk_tree_view_column_get_visible (column))
9225         *x2 = total_width + gtk_tree_view_column_get_width (column);
9226       else
9227         *x2 = total_width; /* width of 0 */
9228     }
9229 }
9230
9231 static void
9232 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
9233                                 GtkRBTree   *tree,
9234                                 gint        *x1,
9235                                 gint        *x2)
9236 {
9237   gint x_offset = 0;
9238   GList *list;
9239   GtkTreeViewColumn *tmp_column = NULL;
9240   gint total_width;
9241   gint expander_size;
9242   gboolean indent_expanders;
9243   gboolean rtl;
9244
9245   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9246   expander_size = gtk_tree_view_get_expander_size (tree_view);
9247
9248   total_width = 0;
9249   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9250        list;
9251        list = (rtl ? list->prev : list->next))
9252     {
9253       tmp_column = list->data;
9254
9255       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
9256         {
9257           if (rtl)
9258             x_offset = total_width + gtk_tree_view_column_get_width (tmp_column) - expander_size;
9259           else
9260             x_offset = total_width;
9261           break;
9262         }
9263
9264       if (gtk_tree_view_column_get_visible (tmp_column))
9265         total_width += gtk_tree_view_column_get_width (tmp_column);
9266     }
9267
9268   gtk_widget_style_get (GTK_WIDGET (tree_view),
9269                         "indent-expanders", &indent_expanders,
9270                         NULL);
9271
9272   if (indent_expanders)
9273     {
9274       if (rtl)
9275         x_offset -= expander_size * _gtk_rbtree_get_depth (tree);
9276       else
9277         x_offset += expander_size * _gtk_rbtree_get_depth (tree);
9278     }
9279
9280   *x1 = x_offset;
9281
9282   if (tmp_column &&
9283       gtk_tree_view_column_get_visible (tmp_column))
9284     /* +1 because x2 isn't included in the range. */
9285     *x2 = *x1 + expander_size + 1;
9286   else
9287     *x2 = *x1;
9288 }
9289
9290 static void
9291 gtk_tree_view_build_tree (GtkTreeView *tree_view,
9292                           GtkRBTree   *tree,
9293                           GtkTreeIter *iter,
9294                           gint         depth,
9295                           gboolean     recurse)
9296 {
9297   GtkRBNode *temp = NULL;
9298   GtkTreePath *path = NULL;
9299
9300   do
9301     {
9302       gtk_tree_model_ref_node (tree_view->priv->model, iter);
9303       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
9304
9305       if (tree_view->priv->fixed_height > 0)
9306         {
9307           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
9308             {
9309               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
9310               _gtk_rbtree_node_mark_valid (tree, temp);
9311             }
9312         }
9313
9314       if (tree_view->priv->is_list)
9315         continue;
9316
9317       if (recurse)
9318         {
9319           GtkTreeIter child;
9320
9321           if (!path)
9322             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
9323           else
9324             gtk_tree_path_next (path);
9325
9326           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
9327             {
9328               gboolean expand;
9329
9330               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
9331
9332               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
9333                   && !expand)
9334                 {
9335                   temp->children = _gtk_rbtree_new ();
9336                   temp->children->parent_tree = tree;
9337                   temp->children->parent_node = temp;
9338                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
9339                 }
9340             }
9341         }
9342
9343       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
9344         {
9345           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
9346             temp->flags ^= GTK_RBNODE_IS_PARENT;
9347         }
9348     }
9349   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
9350
9351   if (path)
9352     gtk_tree_path_free (path);
9353 }
9354
9355 /* Make sure the node is visible vertically */
9356 static void
9357 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
9358                                   GtkRBTree   *tree,
9359                                   GtkRBNode   *node)
9360 {
9361   gint node_dy, height;
9362   GtkTreePath *path = NULL;
9363
9364   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9365     return;
9366
9367   /* just return if the node is visible, avoiding a costly expose */
9368   node_dy = _gtk_rbtree_node_find_offset (tree, node);
9369   height = gtk_tree_view_get_row_height (tree_view, node);
9370   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
9371       && node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment)
9372       && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
9373                               + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
9374     return;
9375
9376   path = _gtk_tree_path_new_from_rbtree (tree, node);
9377   if (path)
9378     {
9379       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
9380       gtk_tree_path_free (path);
9381     }
9382 }
9383
9384 static void
9385 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
9386                                     GtkTreeViewColumn *column,
9387                                     gboolean           focus_to_cell)
9388 {
9389   GtkAllocation allocation;
9390   gint x, width;
9391
9392   if (column == NULL)
9393     return;
9394
9395   gtk_widget_get_allocation (gtk_tree_view_column_get_button (column), &allocation);
9396   x = allocation.x;
9397   width = allocation.width;
9398
9399   if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9400     {
9401       /* The column is larger than the horizontal page size.  If the
9402        * column has cells which can be focussed individually, then we make
9403        * sure the cell which gets focus is fully visible (if even the
9404        * focus cell is bigger than the page size, we make sure the
9405        * left-hand side of the cell is visible).
9406        *
9407        * If the column does not have an activatable cell, we
9408        * make sure the left-hand side of the column is visible.
9409        */
9410
9411       if (focus_to_cell && gtk_tree_view_has_can_focus_cell (tree_view))
9412         {
9413           GtkCellArea *cell_area;
9414           GtkCellRenderer *focus_cell;
9415
9416           cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
9417           focus_cell = gtk_cell_area_get_focus_cell (cell_area);
9418
9419           if (gtk_tree_view_column_cell_get_position (column, focus_cell,
9420                                                       &x, &width))
9421             {
9422               if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
9423                 {
9424                   if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment) < x + width)
9425                     gtk_adjustment_set_value (tree_view->priv->hadjustment,
9426                                               x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9427                   else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9428                     gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9429                 }
9430             }
9431         }
9432
9433       gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9434     }
9435   else
9436     {
9437       if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
9438           gtk_adjustment_set_value (tree_view->priv->hadjustment,
9439                                     x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
9440       else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
9441         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
9442   }
9443 }
9444
9445 /* This function could be more efficient.  I'll optimize it if profiling seems
9446  * to imply that it is important */
9447 GtkTreePath *
9448 _gtk_tree_path_new_from_rbtree (GtkRBTree   *tree,
9449                                 GtkRBNode   *node)
9450 {
9451   GtkTreePath *path;
9452   GtkRBTree *tmp_tree;
9453   GtkRBNode *tmp_node, *last;
9454   gint count;
9455
9456   path = gtk_tree_path_new ();
9457
9458   g_return_val_if_fail (node != NULL, path);
9459
9460   count = 1 + node->left->count;
9461
9462   last = node;
9463   tmp_node = node->parent;
9464   tmp_tree = tree;
9465   while (tmp_tree)
9466     {
9467       while (!_gtk_rbtree_is_nil (tmp_node))
9468         {
9469           if (tmp_node->right == last)
9470             count += 1 + tmp_node->left->count;
9471           last = tmp_node;
9472           tmp_node = tmp_node->parent;
9473         }
9474       gtk_tree_path_prepend_index (path, count - 1);
9475       last = tmp_tree->parent_node;
9476       tmp_tree = tmp_tree->parent_tree;
9477       if (last)
9478         {
9479           count = 1 + last->left->count;
9480           tmp_node = last->parent;
9481         }
9482     }
9483   return path;
9484 }
9485
9486 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
9487  * invalid (ie. points to a node that's not in the tree), *tree and *node are
9488  * both set to NULL.
9489  */
9490 gboolean
9491 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
9492                           GtkTreePath  *path,
9493                           GtkRBTree   **tree,
9494                           GtkRBNode   **node)
9495 {
9496   GtkRBNode *tmpnode = NULL;
9497   GtkRBTree *tmptree = tree_view->priv->tree;
9498   gint *indices = gtk_tree_path_get_indices (path);
9499   gint depth = gtk_tree_path_get_depth (path);
9500   gint i = 0;
9501
9502   *node = NULL;
9503   *tree = NULL;
9504
9505   if (depth == 0 || tmptree == NULL)
9506     return FALSE;
9507   do
9508     {
9509       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
9510       ++i;
9511       if (tmpnode == NULL)
9512         {
9513           *tree = NULL;
9514           *node = NULL;
9515           return FALSE;
9516         }
9517       if (i >= depth)
9518         {
9519           *tree = tmptree;
9520           *node = tmpnode;
9521           return FALSE;
9522         }
9523       *tree = tmptree;
9524       *node = tmpnode;
9525       tmptree = tmpnode->children;
9526       if (tmptree == NULL)
9527         return TRUE;
9528     }
9529   while (1);
9530 }
9531
9532 static gboolean
9533 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9534                                   GtkTreeViewColumn *column)
9535 {
9536   GList *list;
9537
9538   if (tree_view->priv->is_list)
9539     return FALSE;
9540
9541   if (tree_view->priv->expander_column != NULL)
9542     {
9543       if (tree_view->priv->expander_column == column)
9544         return TRUE;
9545       return FALSE;
9546     }
9547   else
9548     {
9549       for (list = tree_view->priv->columns;
9550            list;
9551            list = list->next)
9552         if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
9553           break;
9554       if (list && list->data == column)
9555         return TRUE;
9556     }
9557   return FALSE;
9558 }
9559
9560 static inline gboolean
9561 gtk_tree_view_draw_expanders (GtkTreeView *tree_view)
9562 {
9563   if (!tree_view->priv->is_list && tree_view->priv->show_expanders)
9564     return TRUE;
9565   /* else */
9566   return FALSE;
9567 }
9568
9569 static void
9570 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9571                                 guint           keyval,
9572                                 guint           modmask,
9573                                 gboolean        add_shifted_binding,
9574                                 GtkMovementStep step,
9575                                 gint            count)
9576 {
9577
9578   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9579                                 "move-cursor", 2,
9580                                 G_TYPE_ENUM, step,
9581                                 G_TYPE_INT, count);
9582
9583   if (add_shifted_binding)
9584     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9585                                   "move-cursor", 2,
9586                                   G_TYPE_ENUM, step,
9587                                   G_TYPE_INT, count);
9588
9589   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9590    return;
9591
9592   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9593                                 "move-cursor", 2,
9594                                 G_TYPE_ENUM, step,
9595                                 G_TYPE_INT, count);
9596
9597   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9598                                 "move-cursor", 2,
9599                                 G_TYPE_ENUM, step,
9600                                 G_TYPE_INT, count);
9601 }
9602
9603 static gint
9604 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9605                                  GtkTreeIter  *iter,
9606                                  GtkRBTree    *tree,
9607                                  GtkRBNode    *node)
9608 {
9609   gint retval = FALSE;
9610   do
9611     {
9612       g_return_val_if_fail (node != NULL, FALSE);
9613
9614       if (node->children)
9615         {
9616           GtkTreeIter child;
9617           GtkRBTree *new_tree;
9618           GtkRBNode *new_node;
9619
9620           new_tree = node->children;
9621           new_node = _gtk_rbtree_first (new_tree);
9622
9623           if (!gtk_tree_model_iter_children (model, &child, iter))
9624             return FALSE;
9625
9626           retval = gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node) | retval;
9627         }
9628
9629       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9630         retval = TRUE;
9631       gtk_tree_model_unref_node (model, iter);
9632       node = _gtk_rbtree_next (tree, node);
9633     }
9634   while (gtk_tree_model_iter_next (model, iter));
9635
9636   return retval;
9637 }
9638
9639 static gint
9640 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9641                                               GtkRBTree   *tree)
9642 {
9643   GtkTreeIter iter;
9644   GtkTreePath *path;
9645   GtkRBNode *node;
9646   gint retval;
9647
9648   if (!tree)
9649     return FALSE;
9650
9651   node = _gtk_rbtree_first (tree);
9652
9653   g_return_val_if_fail (node != NULL, FALSE);
9654   path = _gtk_tree_path_new_from_rbtree (tree, node);
9655   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9656                            &iter, path);
9657   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9658   gtk_tree_path_free (path);
9659
9660   return retval;
9661 }
9662
9663 static void
9664 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9665                                     GtkTreeViewColumn *column)
9666 {
9667   GtkTreeViewColumn *left_column;
9668   GtkTreeViewColumn *cur_column = NULL;
9669   GtkTreeViewColumnReorder *reorder;
9670   gboolean rtl;
9671   GList *tmp_list;
9672   gint left;
9673
9674   /* We want to precalculate the motion list such that we know what column slots
9675    * are available.
9676    */
9677   left_column = NULL;
9678   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9679
9680   /* First, identify all possible drop spots */
9681   if (rtl)
9682     tmp_list = g_list_last (tree_view->priv->columns);
9683   else
9684     tmp_list = g_list_first (tree_view->priv->columns);
9685
9686   while (tmp_list)
9687     {
9688       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9689       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9690
9691       if (gtk_tree_view_column_get_visible (cur_column) == FALSE)
9692         continue;
9693
9694       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9695       if (left_column != column && cur_column != column &&
9696           tree_view->priv->column_drop_func &&
9697           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9698         {
9699           left_column = cur_column;
9700           continue;
9701         }
9702       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9703       reorder->left_column = left_column;
9704       left_column = reorder->right_column = cur_column;
9705
9706       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9707     }
9708
9709   /* Add the last one */
9710   if (tree_view->priv->column_drop_func == NULL ||
9711       ((left_column != column) &&
9712        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9713     {
9714       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9715       reorder->left_column = left_column;
9716       reorder->right_column = NULL;
9717       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9718     }
9719
9720   /* We quickly check to see if it even makes sense to reorder columns. */
9721   /* If there is nothing that can be moved, then we return */
9722
9723   if (tree_view->priv->column_drag_info == NULL)
9724     return;
9725
9726   /* We know there are always 2 slots possbile, as you can always return column. */
9727   /* If that's all there is, return */
9728   if (tree_view->priv->column_drag_info->next == NULL ||
9729       (tree_view->priv->column_drag_info->next->next == NULL &&
9730        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9731        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9732     {
9733       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9734         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9735       g_list_free (tree_view->priv->column_drag_info);
9736       tree_view->priv->column_drag_info = NULL;
9737       return;
9738     }
9739   /* We fill in the ranges for the columns, now that we've isolated them */
9740   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9741
9742   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9743     {
9744       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9745
9746       reorder->left_align = left;
9747       if (tmp_list->next != NULL)
9748         {
9749           GtkAllocation right_allocation, left_allocation;
9750           GtkWidget    *left_button, *right_button;
9751
9752           g_assert (tmp_list->next->data);
9753
9754           right_button = gtk_tree_view_column_get_button (reorder->right_column);
9755           left_button  = gtk_tree_view_column_get_button
9756             (((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column);
9757
9758           gtk_widget_get_allocation (right_button, &right_allocation);
9759           gtk_widget_get_allocation (left_button, &left_allocation);
9760           left = reorder->right_align = (right_allocation.x + right_allocation.width + left_allocation.x) / 2;
9761         }
9762       else
9763         {
9764           reorder->right_align = gdk_window_get_width (tree_view->priv->header_window)
9765                                  + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9766         }
9767     }
9768 }
9769
9770 void
9771 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9772                                   GtkTreeViewColumn *column,
9773                                   GdkDevice         *device)
9774 {
9775   GdkEvent *send_event;
9776   GtkAllocation allocation;
9777   GtkAllocation button_allocation;
9778   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9779   GtkWidget *button;
9780   GdkDevice *pointer, *keyboard;
9781   GdkWindowAttr attributes;
9782   guint attributes_mask;
9783   GtkStyleContext *context;
9784
9785   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9786   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9787   g_return_if_fail (tree_view->priv->drag_window == NULL);
9788
9789   gtk_tree_view_set_column_drag_info (tree_view, column);
9790
9791   if (tree_view->priv->column_drag_info == NULL)
9792     return;
9793
9794   button = gtk_tree_view_column_get_button (column);
9795
9796   context = gtk_widget_get_style_context (button);
9797   gtk_style_context_add_class (context, GTK_STYLE_CLASS_DND);
9798
9799   gtk_widget_get_allocation (button, &button_allocation);
9800
9801   attributes.window_type = GDK_WINDOW_CHILD;
9802   attributes.wclass = GDK_INPUT_OUTPUT;
9803   attributes.x = button_allocation.x;
9804   attributes.y = 0;
9805   attributes.width = button_allocation.width;
9806   attributes.height = button_allocation.height;
9807   attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9808   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9809   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
9810
9811   tree_view->priv->drag_window = gdk_window_new (tree_view->priv->header_window,
9812                                                  &attributes,
9813                                                  attributes_mask);
9814   gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_window);
9815
9816   if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
9817     {
9818       keyboard = device;
9819       pointer = gdk_device_get_associated_device (device);
9820     }
9821   else
9822     {
9823       pointer = device;
9824       keyboard = gdk_device_get_associated_device (device);
9825     }
9826
9827   gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
9828   gdk_device_ungrab (keyboard, GDK_CURRENT_TIME);
9829
9830   gtk_grab_remove (button);
9831
9832   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9833   send_event->crossing.send_event = TRUE;
9834   send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (button)));
9835   send_event->crossing.subwindow = NULL;
9836   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9837   send_event->crossing.time = GDK_CURRENT_TIME;
9838   gdk_event_set_device (send_event, device);
9839
9840   gtk_propagate_event (button, send_event);
9841   gdk_event_free (send_event);
9842
9843   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9844   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9845   send_event->button.send_event = TRUE;
9846   send_event->button.time = GDK_CURRENT_TIME;
9847   send_event->button.x = -1;
9848   send_event->button.y = -1;
9849   send_event->button.axes = NULL;
9850   send_event->button.state = 0;
9851   send_event->button.button = GDK_BUTTON_PRIMARY;
9852   send_event->button.x_root = 0;
9853   send_event->button.y_root = 0;
9854   gdk_event_set_device (send_event, device);
9855
9856   gtk_propagate_event (button, send_event);
9857   gdk_event_free (send_event);
9858
9859   /* Kids, don't try this at home */
9860   g_object_ref (button);
9861   gtk_container_remove (GTK_CONTAINER (tree_view), button);
9862   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9863   gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
9864   g_object_unref (button);
9865
9866   gtk_widget_get_allocation (button, &button_allocation);
9867   tree_view->priv->drag_column_x = button_allocation.x;
9868   allocation = button_allocation;
9869   allocation.x = 0;
9870   gtk_widget_size_allocate (button, &allocation);
9871   gtk_widget_set_parent_window (button, tree_view->priv->drag_window);
9872
9873   tree_view->priv->drag_column = column;
9874   gdk_window_show (tree_view->priv->drag_window);
9875
9876   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9877   while (gtk_events_pending ())
9878     gtk_main_iteration ();
9879
9880   tree_view->priv->in_column_drag = TRUE;
9881
9882   gdk_device_grab (pointer,
9883                    tree_view->priv->drag_window,
9884                    GDK_OWNERSHIP_NONE,
9885                    FALSE,
9886                    GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9887                    NULL,
9888                    GDK_CURRENT_TIME);
9889   gdk_device_grab (keyboard,
9890                    tree_view->priv->drag_window,
9891                    GDK_OWNERSHIP_NONE,
9892                    FALSE,
9893                    GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
9894                    NULL,
9895                    GDK_CURRENT_TIME);
9896 }
9897
9898 static void
9899 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9900                                 GtkRBTree          *tree,
9901                                 GtkRBNode          *node)
9902 {
9903   GtkAllocation allocation;
9904   GdkRectangle rect;
9905
9906   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9907     return;
9908
9909   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9910   rect.x = 0;
9911   rect.width = gtk_tree_view_get_expander_size (tree_view);
9912   rect.width = MAX (rect.width, MAX (tree_view->priv->width, allocation.width));
9913
9914   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9915   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9916
9917   gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9918 }
9919
9920 void
9921 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9922                                 GtkRBTree          *tree,
9923                                 GtkRBNode          *node,
9924                                 const GdkRectangle *clip_rect)
9925 {
9926   GtkAllocation allocation;
9927   GdkRectangle rect;
9928
9929   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9930     return;
9931
9932   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9933   rect.x = 0;
9934   rect.width = MAX (tree_view->priv->width, allocation.width);
9935
9936   rect.y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
9937   rect.height = gtk_tree_view_get_row_height (tree_view, node);
9938
9939   if (clip_rect)
9940     {
9941       GdkRectangle new_rect;
9942
9943       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9944
9945       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9946     }
9947   else
9948     {
9949       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9950     }
9951 }
9952
9953 static inline gint
9954 gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view)
9955 {
9956   if (tree_view->priv->headers_visible)
9957     return tree_view->priv->header_height;
9958   /* else */
9959   return 0;
9960 }
9961
9962 gint
9963 _gtk_tree_view_get_header_height (GtkTreeView *tree_view)
9964 {
9965   return tree_view->priv->header_height;
9966 }
9967
9968 void
9969 _gtk_tree_view_get_row_separator_func (GtkTreeView                 *tree_view,
9970                                        GtkTreeViewRowSeparatorFunc *func,
9971                                        gpointer                    *data)
9972 {
9973   *func = tree_view->priv->row_separator_func;
9974   *data = tree_view->priv->row_separator_data;
9975 }
9976
9977 GtkTreePath *
9978 _gtk_tree_view_get_anchor_path (GtkTreeView *tree_view)
9979 {
9980   if (tree_view->priv->anchor)
9981     return gtk_tree_row_reference_get_path (tree_view->priv->anchor);
9982
9983   return NULL;
9984 }
9985
9986 void
9987 _gtk_tree_view_set_anchor_path (GtkTreeView *tree_view,
9988                                 GtkTreePath *anchor_path)
9989 {
9990   if (tree_view->priv->anchor)
9991     {
9992       gtk_tree_row_reference_free (tree_view->priv->anchor);
9993       tree_view->priv->anchor = NULL;
9994     }
9995
9996   if (anchor_path && tree_view->priv->model)
9997     tree_view->priv->anchor =
9998       gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
9999                                         tree_view->priv->model, anchor_path);
10000 }
10001
10002 GtkRBTree *
10003 _gtk_tree_view_get_rbtree (GtkTreeView *tree_view)
10004 {
10005   return tree_view->priv->tree;
10006 }
10007
10008 gboolean
10009 _gtk_tree_view_get_cursor_node (GtkTreeView  *tree_view,
10010                                 GtkRBTree   **tree,
10011                                 GtkRBNode   **node)
10012 {
10013   GtkTreeViewPrivate *priv;
10014
10015   priv = tree_view->priv;
10016
10017   if (priv->cursor_node == NULL)
10018     return FALSE;
10019
10020   *tree = priv->cursor_tree;
10021   *node = priv->cursor_node;
10022
10023   return TRUE;
10024 }
10025
10026 GdkWindow *
10027 _gtk_tree_view_get_header_window (GtkTreeView *tree_view)
10028 {
10029   return tree_view->priv->header_window;
10030 }
10031
10032 GtkTreeViewColumn *
10033 _gtk_tree_view_get_focus_column (GtkTreeView *tree_view)
10034 {
10035   return tree_view->priv->focus_column;
10036 }
10037
10038 void
10039 _gtk_tree_view_set_focus_column (GtkTreeView       *tree_view,
10040                                  GtkTreeViewColumn *column)
10041 {
10042   GtkTreeViewColumn *old_column = tree_view->priv->focus_column;
10043
10044   if (old_column == column)
10045     return;
10046
10047   tree_view->priv->focus_column = column;
10048
10049   _gtk_tree_view_accessible_update_focus_column (tree_view,
10050                                                  old_column,
10051                                                  column);
10052 }
10053
10054
10055 static void
10056 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
10057                                GtkTreePath        *path,
10058                                const GdkRectangle *clip_rect)
10059 {
10060   GtkRBTree *tree = NULL;
10061   GtkRBNode *node = NULL;
10062
10063   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
10064
10065   if (tree)
10066     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
10067 }
10068
10069 /* x and y are the mouse position
10070  */
10071 static void
10072 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
10073                           cairo_t     *cr,
10074                           GtkRBTree   *tree,
10075                           GtkRBNode   *node)
10076 {
10077   GdkRectangle area;
10078   GtkStateFlags state = 0;
10079   GtkStyleContext *context;
10080   GtkWidget *widget;
10081   gint x_offset = 0;
10082   gint x2;
10083   gint vertical_separator;
10084   gint expander_size;
10085   GtkCellRendererState flags = 0;
10086
10087   widget = GTK_WIDGET (tree_view);
10088   context = gtk_widget_get_style_context (widget);
10089
10090   gtk_widget_style_get (widget,
10091                         "vertical-separator", &vertical_separator,
10092                         NULL);
10093   expander_size = gtk_tree_view_get_expander_size (tree_view);
10094
10095   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
10096     return;
10097
10098   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
10099
10100   area.x = x_offset;
10101   area.y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
10102                                                  vertical_separator);
10103   area.width = expander_size;
10104   area.height = gtk_tree_view_get_cell_area_height (tree_view, node,
10105                                                     vertical_separator);
10106
10107   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
10108     flags |= GTK_CELL_RENDERER_SELECTED;
10109
10110   if (node == tree_view->priv->prelight_node &&
10111       tree_view->priv->arrow_prelit)
10112     flags |= GTK_CELL_RENDERER_PRELIT;
10113
10114   state = gtk_cell_renderer_get_state (NULL, widget, flags);
10115
10116   if (node->children != NULL)
10117     state |= GTK_STATE_FLAG_ACTIVE;
10118   else
10119     state &= ~(GTK_STATE_FLAG_ACTIVE);
10120
10121   gtk_style_context_save (context);
10122
10123   gtk_style_context_set_state (context, state);
10124   gtk_style_context_add_class (context, GTK_STYLE_CLASS_EXPANDER);
10125
10126   gtk_render_expander (context, cr,
10127                        area.x, area.y,
10128                        area.width, area.height);
10129
10130   gtk_style_context_restore (context);
10131 }
10132
10133 static void
10134 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
10135
10136 {
10137   GtkTreePath *cursor_path;
10138
10139   if ((tree_view->priv->tree == NULL) ||
10140       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
10141     return;
10142
10143   cursor_path = NULL;
10144   if (tree_view->priv->cursor_node)
10145     cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10146                                                   tree_view->priv->cursor_node);
10147
10148   if (cursor_path == NULL)
10149     {
10150       /* Consult the selection before defaulting to the
10151        * first focusable element
10152        */
10153       GList *selected_rows;
10154       GtkTreeModel *model;
10155       GtkTreeSelection *selection;
10156
10157       selection = gtk_tree_view_get_selection (tree_view);
10158       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
10159
10160       if (selected_rows)
10161         {
10162           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
10163           g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_path_free);
10164         }
10165       else
10166         {
10167           cursor_path = gtk_tree_path_new_first ();
10168           search_first_focusable_path (tree_view, &cursor_path,
10169                                        TRUE, NULL, NULL);
10170         }
10171
10172       if (cursor_path)
10173         {
10174           if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE)
10175             gtk_tree_view_real_set_cursor (tree_view, cursor_path, 0);
10176           else
10177             gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10178         }
10179     }
10180
10181   if (cursor_path)
10182     {
10183       tree_view->priv->draw_keyfocus = TRUE;
10184
10185       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10186       gtk_tree_path_free (cursor_path);
10187
10188       if (tree_view->priv->focus_column == NULL)
10189         {
10190           GList *list;
10191           for (list = tree_view->priv->columns; list; list = list->next)
10192             {
10193               if (gtk_tree_view_column_get_visible (GTK_TREE_VIEW_COLUMN (list->data)))
10194                 {
10195                   GtkCellArea *cell_area;
10196
10197                   _gtk_tree_view_set_focus_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data));
10198
10199                   /* This happens when the treeview initially grabs focus and there
10200                    * is no column in focus, here we explicitly focus into the first cell */
10201                   cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10202                   if (!gtk_cell_area_get_focus_cell (cell_area))
10203                     {
10204                       gboolean rtl;
10205
10206                       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10207                       gtk_cell_area_focus (cell_area,
10208                                            rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT);
10209                     }
10210
10211                   break;
10212                 }
10213             }
10214         }
10215     }
10216 }
10217
10218 static void
10219 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
10220                                    gint         count)
10221 {
10222   gint selection_count;
10223   GtkRBTree *new_cursor_tree = NULL;
10224   GtkRBNode *new_cursor_node = NULL;
10225   GtkTreePath *cursor_path = NULL;
10226   gboolean grab_focus = TRUE;
10227   gboolean selectable;
10228   GtkDirectionType direction;
10229   GtkCellArea *cell_area = NULL;
10230   GtkCellRenderer *last_focus_cell = NULL;
10231   GtkTreeIter iter;
10232
10233   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10234     return;
10235
10236   if (tree_view->priv->cursor_node == NULL)
10237     return;
10238
10239   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10240                                                 tree_view->priv->cursor_node);
10241
10242   direction = count < 0 ? GTK_DIR_UP : GTK_DIR_DOWN;
10243
10244   if (tree_view->priv->focus_column)
10245     cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10246
10247   /* If focus stays in the area for this row, then just return for this round */
10248   if (cell_area && (count == -1 || count == 1) &&
10249       gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path))
10250     {
10251       gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
10252                                                tree_view->priv->model,
10253                                                &iter,
10254                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10255                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10256
10257       /* Save the last cell that had focus, if we hit the end of the view we'll give
10258        * focus back to it. */
10259       last_focus_cell = gtk_cell_area_get_focus_cell (cell_area);
10260
10261       /* If focus stays in the area, no need to change the cursor row */
10262       if (gtk_cell_area_focus (cell_area, direction))
10263         return;
10264     }
10265
10266   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
10267   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
10268                                                       tree_view->priv->cursor_node,
10269                                                       cursor_path);
10270
10271   if (selection_count == 0
10272       && gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_NONE
10273       && !tree_view->priv->modify_selection_pressed
10274       && selectable)
10275     {
10276       /* Don't move the cursor, but just select the current node */
10277       new_cursor_tree = tree_view->priv->cursor_tree;
10278       new_cursor_node = tree_view->priv->cursor_node;
10279     }
10280   else
10281     {
10282       if (count == -1)
10283         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10284                                &new_cursor_tree, &new_cursor_node);
10285       else
10286         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10287                                &new_cursor_tree, &new_cursor_node);
10288     }
10289
10290   gtk_tree_path_free (cursor_path);
10291
10292   if (new_cursor_node)
10293     {
10294       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10295
10296       search_first_focusable_path (tree_view, &cursor_path,
10297                                    (count != -1),
10298                                    &new_cursor_tree,
10299                                    &new_cursor_node);
10300
10301       if (cursor_path)
10302         gtk_tree_path_free (cursor_path);
10303     }
10304
10305   /*
10306    * If the list has only one item and multi-selection is set then select
10307    * the row (if not yet selected).
10308    */
10309   if (gtk_tree_selection_get_mode (tree_view->priv->selection) == GTK_SELECTION_MULTIPLE &&
10310       new_cursor_node == NULL)
10311     {
10312       if (count == -1)
10313         _gtk_rbtree_next_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10314                                &new_cursor_tree, &new_cursor_node);
10315       else
10316         _gtk_rbtree_prev_full (tree_view->priv->cursor_tree, tree_view->priv->cursor_node,
10317                                &new_cursor_tree, &new_cursor_node);
10318
10319       if (new_cursor_node == NULL
10320           && !GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
10321         {
10322           new_cursor_node = tree_view->priv->cursor_node;
10323           new_cursor_tree = tree_view->priv->cursor_tree;
10324         }
10325       else
10326         {
10327           new_cursor_tree = NULL;
10328           new_cursor_node = NULL;
10329         }
10330     }
10331
10332   if (new_cursor_node)
10333     {
10334       cursor_path = _gtk_tree_path_new_from_rbtree (new_cursor_tree, new_cursor_node);
10335       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10336       gtk_tree_path_free (cursor_path);
10337
10338       /* Give focus to the area in the new row */
10339       if (cell_area)
10340         gtk_cell_area_focus (cell_area, direction);
10341     }
10342   else
10343     {
10344       gtk_tree_view_clamp_node_visible (tree_view,
10345                                         tree_view->priv->cursor_tree,
10346                                         tree_view->priv->cursor_node);
10347
10348       if (!tree_view->priv->extend_selection_pressed)
10349         {
10350           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
10351                                           count < 0 ?
10352                                           GTK_DIR_UP : GTK_DIR_DOWN))
10353             {
10354               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10355
10356               if (toplevel)
10357                 gtk_widget_child_focus (toplevel,
10358                                         count < 0 ?
10359                                         GTK_DIR_TAB_BACKWARD :
10360                                         GTK_DIR_TAB_FORWARD);
10361
10362               grab_focus = FALSE;
10363             }
10364         }
10365       else
10366         {
10367           gtk_widget_error_bell (GTK_WIDGET (tree_view));
10368         }
10369
10370       if (cell_area)
10371         gtk_cell_area_set_focus_cell (cell_area, last_focus_cell);
10372     }
10373
10374   if (grab_focus)
10375     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10376 }
10377
10378 static void
10379 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
10380                                         gint         count)
10381 {
10382   GtkTreePath *old_cursor_path = NULL;
10383   GtkTreePath *cursor_path = NULL;
10384   GtkRBTree *start_cursor_tree = NULL;
10385   GtkRBNode *start_cursor_node = NULL;
10386   GtkRBTree *cursor_tree;
10387   GtkRBNode *cursor_node;
10388   gint y;
10389   gint window_y;
10390   gint vertical_separator;
10391
10392   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10393     return;
10394
10395   if (tree_view->priv->cursor_node == NULL)
10396     return;
10397
10398   old_cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10399                                                     tree_view->priv->cursor_node);
10400
10401   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
10402
10403   y = _gtk_rbtree_node_find_offset (tree_view->priv->cursor_tree, tree_view->priv->cursor_node);
10404   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
10405   y += tree_view->priv->cursor_offset;
10406   y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
10407   y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment),  (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
10408
10409   if (y >= tree_view->priv->height)
10410     y = tree_view->priv->height - 1;
10411
10412   tree_view->priv->cursor_offset =
10413     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
10414                              &cursor_tree, &cursor_node);
10415
10416   if (cursor_tree == NULL)
10417     {
10418       /* FIXME: we lost the cursor.  Should we try to get one? */
10419       gtk_tree_path_free (old_cursor_path);
10420       return;
10421     }
10422
10423   if (tree_view->priv->cursor_offset
10424       > gtk_tree_view_get_row_height (tree_view, cursor_node))
10425     {
10426       _gtk_rbtree_next_full (cursor_tree, cursor_node,
10427                              &cursor_tree, &cursor_node);
10428       tree_view->priv->cursor_offset -= gtk_tree_view_get_row_height (tree_view, cursor_node);
10429     }
10430
10431   y -= tree_view->priv->cursor_offset;
10432   cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10433
10434   start_cursor_tree = cursor_tree;
10435   start_cursor_node = cursor_node;
10436
10437   if (! search_first_focusable_path (tree_view, &cursor_path,
10438                                      (count != -1),
10439                                      &cursor_tree, &cursor_node))
10440     {
10441       /* It looks like we reached the end of the view without finding
10442        * a focusable row.  We will step backwards to find the last
10443        * focusable row.
10444        */
10445       cursor_tree = start_cursor_tree;
10446       cursor_node = start_cursor_node;
10447       cursor_path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10448
10449       search_first_focusable_path (tree_view, &cursor_path,
10450                                    (count == -1),
10451                                    &cursor_tree, &cursor_node);
10452     }
10453
10454   if (!cursor_path)
10455     goto cleanup;
10456
10457   /* update y */
10458   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
10459
10460   gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT);
10461
10462   y -= window_y;
10463   gtk_tree_view_scroll_to_point (tree_view, -1, y);
10464   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10465   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10466
10467   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
10468     gtk_widget_error_bell (GTK_WIDGET (tree_view));
10469
10470   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10471
10472 cleanup:
10473   gtk_tree_path_free (old_cursor_path);
10474   gtk_tree_path_free (cursor_path);
10475 }
10476
10477 static void
10478 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
10479                                       gint         count)
10480 {
10481   GtkTreePath *cursor_path = NULL;
10482   GtkTreeViewColumn *column;
10483   GtkTreeIter iter;
10484   GList *list;
10485   gboolean found_column = FALSE;
10486   gboolean rtl;
10487   GtkDirectionType direction;
10488   GtkCellArea     *cell_area;
10489   GtkCellRenderer *last_focus_cell = NULL;
10490   GtkCellArea     *last_focus_area = NULL;
10491
10492   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10493
10494   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10495     return;
10496
10497   if (tree_view->priv->cursor_node == NULL)
10498     return;
10499
10500   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10501                                                 tree_view->priv->cursor_node);
10502
10503   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
10504     {
10505       gtk_tree_path_free (cursor_path);
10506       return;
10507     }
10508   gtk_tree_path_free (cursor_path);
10509
10510   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
10511   if (tree_view->priv->focus_column)
10512     {
10513       /* Save the cell/area we are moving focus from, if moving the cursor
10514        * by one step hits the end we'll set focus back here */
10515       last_focus_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->focus_column));
10516       last_focus_cell = gtk_cell_area_get_focus_cell (last_focus_area);
10517
10518       for (; list; list = (rtl ? list->prev : list->next))
10519         {
10520           if (list->data == tree_view->priv->focus_column)
10521             break;
10522         }
10523     }
10524
10525   direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
10526
10527   while (list)
10528     {
10529       column = list->data;
10530       if (gtk_tree_view_column_get_visible (column) == FALSE)
10531         goto loop_end;
10532
10533       gtk_tree_view_column_cell_set_cell_data (column,
10534                                                tree_view->priv->model,
10535                                                &iter,
10536                                                GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT),
10537                                                tree_view->priv->cursor_node->children ? TRUE : FALSE);
10538
10539       cell_area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
10540       if (gtk_cell_area_focus (cell_area, direction))
10541         {
10542           _gtk_tree_view_set_focus_column (tree_view, column);
10543           found_column = TRUE;
10544           break;
10545         }
10546
10547     loop_end:
10548       if (count == 1)
10549         list = rtl ? list->prev : list->next;
10550       else
10551         list = rtl ? list->next : list->prev;
10552     }
10553
10554   if (found_column)
10555     {
10556       if (!gtk_tree_view_has_can_focus_cell (tree_view))
10557         _gtk_tree_view_queue_draw_node (tree_view,
10558                                         tree_view->priv->cursor_tree,
10559                                         tree_view->priv->cursor_node,
10560                                         NULL);
10561       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
10562       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10563     }
10564   else
10565     {
10566       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10567
10568       if (last_focus_area)
10569         gtk_cell_area_set_focus_cell (last_focus_area, last_focus_cell);
10570     }
10571
10572   gtk_tree_view_clamp_column_visible (tree_view,
10573                                       tree_view->priv->focus_column, TRUE);
10574 }
10575
10576 static void
10577 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
10578                                      gint         count)
10579 {
10580   GtkRBTree *cursor_tree;
10581   GtkRBNode *cursor_node;
10582   GtkTreePath *path;
10583   GtkTreePath *old_path;
10584
10585   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10586     return;
10587
10588   g_return_if_fail (tree_view->priv->tree != NULL);
10589
10590   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
10591
10592   cursor_tree = tree_view->priv->tree;
10593
10594   if (count == -1)
10595     {
10596       cursor_node = _gtk_rbtree_first (cursor_tree);
10597
10598       /* Now go forward to find the first focusable row. */
10599       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10600       search_first_focusable_path (tree_view, &path,
10601                                    TRUE, &cursor_tree, &cursor_node);
10602     }
10603   else
10604     {
10605       cursor_node = cursor_tree->root;
10606
10607       do
10608         {
10609           while (cursor_node && !_gtk_rbtree_is_nil (cursor_node->right))
10610             cursor_node = cursor_node->right;
10611           if (cursor_node->children == NULL)
10612             break;
10613
10614           cursor_tree = cursor_node->children;
10615           cursor_node = cursor_tree->root;
10616         }
10617       while (1);
10618
10619       /* Now go backwards to find last focusable row. */
10620       path = _gtk_tree_path_new_from_rbtree (cursor_tree, cursor_node);
10621       search_first_focusable_path (tree_view, &path,
10622                                    FALSE, &cursor_tree, &cursor_node);
10623     }
10624
10625   if (!path)
10626     goto cleanup;
10627
10628   if (gtk_tree_path_compare (old_path, path))
10629     {
10630       gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
10631       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10632     }
10633   else
10634     {
10635       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10636     }
10637
10638 cleanup:
10639   gtk_tree_path_free (old_path);
10640   gtk_tree_path_free (path);
10641 }
10642
10643 static gboolean
10644 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10645 {
10646   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10647     return FALSE;
10648
10649   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10650     return FALSE;
10651
10652   gtk_tree_selection_select_all (tree_view->priv->selection);
10653
10654   return TRUE;
10655 }
10656
10657 static gboolean
10658 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
10659 {
10660   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10661     return FALSE;
10662
10663   if (gtk_tree_selection_get_mode (tree_view->priv->selection) != GTK_SELECTION_MULTIPLE)
10664     return FALSE;
10665
10666   gtk_tree_selection_unselect_all (tree_view->priv->selection);
10667
10668   return TRUE;
10669 }
10670
10671 static gboolean
10672 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10673                                       gboolean     start_editing)
10674 {
10675   GtkRBTree *new_tree = NULL;
10676   GtkRBNode *new_node = NULL;
10677   GtkRBTree *cursor_tree = NULL;
10678   GtkRBNode *cursor_node = NULL;
10679   GtkTreePath *cursor_path = NULL;
10680   GtkTreeSelectMode mode = 0;
10681
10682   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10683     return FALSE;
10684
10685   if (tree_view->priv->cursor_node == NULL)
10686     return FALSE;
10687
10688   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10689                                                 tree_view->priv->cursor_node);
10690
10691   _gtk_tree_view_find_node (tree_view, cursor_path,
10692                             &cursor_tree, &cursor_node);
10693
10694   if (cursor_tree == NULL)
10695     {
10696       gtk_tree_path_free (cursor_path);
10697       return FALSE;
10698     }
10699
10700   if (!tree_view->priv->extend_selection_pressed && start_editing &&
10701       tree_view->priv->focus_column)
10702     {
10703       if (gtk_tree_view_start_editing (tree_view, cursor_path, FALSE))
10704         {
10705           gtk_tree_path_free (cursor_path);
10706           return TRUE;
10707         }
10708     }
10709
10710   if (tree_view->priv->modify_selection_pressed)
10711     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10712   if (tree_view->priv->extend_selection_pressed)
10713     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10714
10715   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10716                                             cursor_node,
10717                                             cursor_tree,
10718                                             cursor_path,
10719                                             mode,
10720                                             FALSE);
10721
10722   /* We bail out if the original (tree, node) don't exist anymore after
10723    * handling the selection-changed callback.  We do return TRUE because
10724    * the key press has been handled at this point.
10725    */
10726   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10727
10728   if (cursor_tree != new_tree || cursor_node != new_node)
10729     return FALSE;
10730
10731   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10732
10733   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10734   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10735
10736   if (!tree_view->priv->extend_selection_pressed)
10737     gtk_tree_view_row_activated (tree_view, cursor_path,
10738                                  tree_view->priv->focus_column);
10739
10740   gtk_tree_path_free (cursor_path);
10741
10742   return TRUE;
10743 }
10744
10745 static gboolean
10746 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10747 {
10748   GtkRBTree *new_tree = NULL;
10749   GtkRBNode *new_node = NULL;
10750   GtkTreePath *cursor_path = NULL;
10751
10752   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10753     return FALSE;
10754
10755   if (tree_view->priv->cursor_node == NULL)
10756     return FALSE;
10757
10758   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10759                                                 tree_view->priv->cursor_node);
10760
10761   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10762                                             tree_view->priv->cursor_node,
10763                                             tree_view->priv->cursor_tree,
10764                                             cursor_path,
10765                                             GTK_TREE_SELECT_MODE_TOGGLE,
10766                                             FALSE);
10767
10768   /* We bail out if the original (tree, node) don't exist anymore after
10769    * handling the selection-changed callback.  We do return TRUE because
10770    * the key press has been handled at this point.
10771    */
10772   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10773
10774   if (tree_view->priv->cursor_node != new_node)
10775     return FALSE;
10776
10777   gtk_tree_view_clamp_node_visible (tree_view,
10778                                     tree_view->priv->cursor_tree,
10779                                     tree_view->priv->cursor_node);
10780
10781   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10782   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10783   gtk_tree_path_free (cursor_path);
10784
10785   return TRUE;
10786 }
10787
10788 static gboolean
10789 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10790                                                gboolean     logical,
10791                                                gboolean     expand,
10792                                                gboolean     open_all)
10793 {
10794   GtkTreePath *cursor_path = NULL;
10795
10796   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10797     return FALSE;
10798
10799   if (tree_view->priv->cursor_node == NULL)
10800     return FALSE;
10801
10802   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10803                                                 tree_view->priv->cursor_node);
10804
10805   /* Don't handle the event if we aren't an expander */
10806   if (!GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_PARENT))
10807     return FALSE;
10808
10809   if (!logical
10810       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10811     expand = !expand;
10812
10813   if (expand)
10814     gtk_tree_view_real_expand_row (tree_view,
10815                                    cursor_path,
10816                                    tree_view->priv->cursor_tree,
10817                                    tree_view->priv->cursor_node,
10818                                    open_all,
10819                                    TRUE);
10820   else
10821     gtk_tree_view_real_collapse_row (tree_view,
10822                                      cursor_path,
10823                                      tree_view->priv->cursor_tree,
10824                                      tree_view->priv->cursor_node,
10825                                      TRUE);
10826
10827   gtk_tree_path_free (cursor_path);
10828
10829   return TRUE;
10830 }
10831
10832 static gboolean
10833 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10834 {
10835   GtkTreePath *cursor_path = NULL;
10836   GdkModifierType state;
10837
10838   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10839     goto out;
10840
10841   if (tree_view->priv->cursor_node == NULL)
10842     goto out;
10843
10844   cursor_path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
10845                                                 tree_view->priv->cursor_node);
10846
10847   if (tree_view->priv->cursor_tree->parent_node)
10848     {
10849       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10850
10851       gtk_tree_path_up (cursor_path);
10852
10853       if (gtk_get_current_event_state (&state))
10854         {
10855           GdkModifierType modify_mod_mask;
10856
10857           modify_mod_mask =
10858             gtk_widget_get_modifier_mask (GTK_WIDGET (tree_view),
10859                                           GDK_MODIFIER_INTENT_MODIFY_SELECTION);
10860
10861           if ((state & modify_mod_mask) == modify_mod_mask)
10862             tree_view->priv->modify_selection_pressed = TRUE;
10863         }
10864
10865       gtk_tree_view_real_set_cursor (tree_view, cursor_path, CLEAR_AND_SELECT | CLAMP_NODE);
10866       gtk_tree_path_free (cursor_path);
10867
10868       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10869
10870       tree_view->priv->modify_selection_pressed = FALSE;
10871
10872       return TRUE;
10873     }
10874
10875  out:
10876
10877   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10878   return FALSE;
10879 }
10880
10881 static gboolean
10882 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10883 {
10884   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
10885   tree_view->priv->typeselect_flush_timeout = 0;
10886
10887   return FALSE;
10888 }
10889
10890 /* Cut and paste from gtkwindow.c */
10891 static void
10892 send_focus_change (GtkWidget *widget,
10893                    GdkDevice *device,
10894                    gboolean   in)
10895 {
10896   GdkDeviceManager *device_manager;
10897   GList *devices, *d;
10898
10899   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
10900   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
10901   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
10902   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
10903
10904   for (d = devices; d; d = d->next)
10905     {
10906       GdkDevice *dev = d->data;
10907       GdkEvent *fevent;
10908       GdkWindow *window;
10909
10910       if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
10911         continue;
10912
10913       window = gtk_widget_get_window (widget);
10914
10915       /* Skip non-master keyboards that haven't
10916        * selected for events from this window
10917        */
10918       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
10919           !gdk_window_get_device_events (window, dev))
10920         continue;
10921
10922       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10923
10924       fevent->focus_change.type = GDK_FOCUS_CHANGE;
10925       fevent->focus_change.window = g_object_ref (window);
10926       fevent->focus_change.in = in;
10927       gdk_event_set_device (fevent, device);
10928
10929       gtk_widget_send_focus_change (widget, fevent);
10930
10931       gdk_event_free (fevent);
10932     }
10933
10934   g_list_free (devices);
10935 }
10936
10937 static void
10938 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10939 {
10940   GtkWidget *frame, *vbox, *toplevel;
10941   GdkScreen *screen;
10942
10943   if (tree_view->priv->search_custom_entry_set)
10944     return;
10945
10946   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10947   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10948
10949    if (tree_view->priv->search_window != NULL)
10950      {
10951        if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10952          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10953                                       GTK_WINDOW (tree_view->priv->search_window));
10954        else if (gtk_window_has_group (GTK_WINDOW (tree_view->priv->search_window)))
10955          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
10956                                          GTK_WINDOW (tree_view->priv->search_window));
10957
10958        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10959
10960        return;
10961      }
10962
10963   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10964   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10965
10966   if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10967     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10968                                  GTK_WINDOW (tree_view->priv->search_window));
10969
10970   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10971                             GDK_WINDOW_TYPE_HINT_UTILITY);
10972   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10973   g_signal_connect (tree_view->priv->search_window, "delete-event",
10974                     G_CALLBACK (gtk_tree_view_search_delete_event),
10975                     tree_view);
10976   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10977                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10978                     tree_view);
10979   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10980                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10981                     tree_view);
10982   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10983                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10984                     tree_view);
10985
10986   frame = gtk_frame_new (NULL);
10987   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10988   gtk_widget_show (frame);
10989   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10990
10991   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10992   gtk_widget_show (vbox);
10993   gtk_container_add (GTK_CONTAINER (frame), vbox);
10994   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
10995
10996   /* add entry */
10997   tree_view->priv->search_entry = gtk_entry_new ();
10998   gtk_widget_show (tree_view->priv->search_entry);
10999   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
11000                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
11001                     tree_view);
11002   g_signal_connect (tree_view->priv->search_entry,
11003                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
11004                     tree_view);
11005
11006   g_signal_connect (_gtk_entry_get_im_context (GTK_ENTRY (tree_view->priv->search_entry)),
11007                     "preedit-changed",
11008                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
11009                     tree_view);
11010
11011   gtk_container_add (GTK_CONTAINER (vbox),
11012                      tree_view->priv->search_entry);
11013
11014   gtk_widget_realize (tree_view->priv->search_entry);
11015 }
11016
11017 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
11018  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
11019  */
11020 static gboolean
11021 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
11022                                              GdkDevice   *device,
11023                                              gboolean     keybinding)
11024 {
11025   /* We only start interactive search if we have focus or the columns
11026    * have focus.  If one of our children have focus, we don't want to
11027    * start the search.
11028    */
11029   GList *list;
11030   gboolean found_focus = FALSE;
11031   GtkWidgetClass *entry_parent_class;
11032
11033   if (!tree_view->priv->enable_search && !keybinding)
11034     return FALSE;
11035
11036   if (tree_view->priv->search_custom_entry_set)
11037     return FALSE;
11038
11039   if (tree_view->priv->search_window != NULL &&
11040       gtk_widget_get_visible (tree_view->priv->search_window))
11041     return TRUE;
11042
11043   for (list = tree_view->priv->columns; list; list = list->next)
11044     {
11045       GtkTreeViewColumn *column;
11046       GtkWidget         *button;
11047
11048       column = list->data;
11049       if (!gtk_tree_view_column_get_visible (column))
11050         continue;
11051
11052       button = gtk_tree_view_column_get_button (column);
11053       if (gtk_widget_has_focus (button))
11054         {
11055           found_focus = TRUE;
11056           break;
11057         }
11058     }
11059
11060   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
11061     found_focus = TRUE;
11062
11063   if (!found_focus)
11064     return FALSE;
11065
11066   if (tree_view->priv->search_column < 0)
11067     return FALSE;
11068
11069   gtk_tree_view_ensure_interactive_directory (tree_view);
11070
11071   if (keybinding)
11072     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
11073
11074   /* done, show it */
11075   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
11076   gtk_widget_show (tree_view->priv->search_window);
11077   if (tree_view->priv->search_entry_changed_id == 0)
11078     {
11079       tree_view->priv->search_entry_changed_id =
11080         g_signal_connect (tree_view->priv->search_entry, "changed",
11081                           G_CALLBACK (gtk_tree_view_search_init),
11082                           tree_view);
11083     }
11084
11085   tree_view->priv->typeselect_flush_timeout =
11086     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
11087                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
11088                    tree_view);
11089
11090   /* Grab focus will select all the text.  We don't want that to happen, so we
11091    * call the parent instance and bypass the selection change.  This is probably
11092    * really non-kosher. */
11093   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
11094   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
11095
11096   /* send focus-in event */
11097   send_focus_change (tree_view->priv->search_entry, device, TRUE);
11098
11099   /* search first matching iter */
11100   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
11101
11102   return TRUE;
11103 }
11104
11105 static gboolean
11106 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
11107 {
11108   return gtk_tree_view_real_start_interactive_search (tree_view,
11109                                                       gtk_get_current_event_device (),
11110                                                       TRUE);
11111 }
11112
11113 /* FIXME this adjust_allocation is a big cut-and-paste from
11114  * GtkCList, needs to be some "official" way to do this
11115  * factored out.
11116  */
11117 typedef struct
11118 {
11119   GdkWindow *window;
11120   int dx;
11121   int dy;
11122 } ScrollData;
11123
11124 /* The window to which widget->window is relative */
11125 #define ALLOCATION_WINDOW(widget)               \
11126    (!gtk_widget_get_has_window (widget) ?                   \
11127     gtk_widget_get_window (widget) :                        \
11128     gdk_window_get_parent (gtk_widget_get_window (widget)))
11129
11130 static void
11131 adjust_allocation_recurse (GtkWidget *widget,
11132                            gpointer   data)
11133 {
11134   GtkAllocation allocation;
11135   ScrollData *scroll_data = data;
11136
11137   /* Need to really size allocate instead of just poking
11138    * into widget->allocation if the widget is not realized.
11139    * FIXME someone figure out why this was.
11140    */
11141   gtk_widget_get_allocation (widget, &allocation);
11142   if (!gtk_widget_get_realized (widget))
11143     {
11144       if (gtk_widget_get_visible (widget))
11145         {
11146           GdkRectangle tmp_rectangle = allocation;
11147           tmp_rectangle.x += scroll_data->dx;
11148           tmp_rectangle.y += scroll_data->dy;
11149
11150           gtk_widget_size_allocate (widget, &tmp_rectangle);
11151         }
11152     }
11153   else
11154     {
11155       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
11156         {
11157           allocation.x += scroll_data->dx;
11158           allocation.y += scroll_data->dy;
11159           gtk_widget_set_allocation (widget, &allocation);
11160
11161           if (GTK_IS_CONTAINER (widget))
11162             gtk_container_forall (GTK_CONTAINER (widget),
11163                                   adjust_allocation_recurse,
11164                                   data);
11165         }
11166     }
11167 }
11168
11169 static void
11170 adjust_allocation (GtkWidget *widget,
11171                    int        dx,
11172                    int        dy)
11173 {
11174   ScrollData scroll_data;
11175
11176   if (gtk_widget_get_realized (widget))
11177     scroll_data.window = ALLOCATION_WINDOW (widget);
11178   else
11179     scroll_data.window = NULL;
11180
11181   scroll_data.dx = dx;
11182   scroll_data.dy = dy;
11183
11184   adjust_allocation_recurse (widget, &scroll_data);
11185 }
11186
11187 /* Callbacks */
11188 static void
11189 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
11190                                   GtkTreeView   *tree_view)
11191 {
11192   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11193     {
11194       gint dy;
11195
11196       gdk_window_move (tree_view->priv->bin_window,
11197                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11198                        gtk_tree_view_get_effective_header_height (tree_view));
11199       gdk_window_move (tree_view->priv->header_window,
11200                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
11201                        0);
11202       dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11203       if (dy)
11204         {
11205           update_prelight (tree_view,
11206                            tree_view->priv->event_last_x,
11207                            tree_view->priv->event_last_y - dy);
11208
11209           if (tree_view->priv->edited_column)
11210             {
11211               GList *list;
11212               GtkTreeViewChild *child = NULL;
11213               GtkCellEditable *edit_widget;
11214               GtkCellArea *area;
11215
11216               area        = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column));
11217               edit_widget = gtk_cell_area_get_edit_widget (area);
11218               if (GTK_IS_WIDGET (edit_widget))
11219                 {
11220                   adjust_allocation (GTK_WIDGET (edit_widget), 0, dy);
11221
11222                   for (list = tree_view->priv->children; list; list = list->next)
11223                     {
11224                       child = (GtkTreeViewChild *)list->data;
11225                       if (child->widget == GTK_WIDGET (edit_widget))
11226                         {
11227                           child->y += dy;
11228                           break;
11229                         }
11230                     }
11231                 }
11232             }
11233         }
11234       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
11235
11236       if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
11237         {
11238           /* update our dy and top_row */
11239           tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
11240
11241           if (!tree_view->priv->in_top_row_to_dy)
11242             gtk_tree_view_dy_to_top_row (tree_view);
11243         }
11244     }
11245 }
11246
11247 \f
11248
11249 /* Public methods
11250  */
11251
11252 /**
11253  * gtk_tree_view_new:
11254  *
11255  * Creates a new #GtkTreeView widget.
11256  *
11257  * Return value: A newly created #GtkTreeView widget.
11258  **/
11259 GtkWidget *
11260 gtk_tree_view_new (void)
11261 {
11262   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
11263 }
11264
11265 /**
11266  * gtk_tree_view_new_with_model:
11267  * @model: the model.
11268  *
11269  * Creates a new #GtkTreeView widget with the model initialized to @model.
11270  *
11271  * Return value: A newly created #GtkTreeView widget.
11272  **/
11273 GtkWidget *
11274 gtk_tree_view_new_with_model (GtkTreeModel *model)
11275 {
11276   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
11277 }
11278
11279 /* Public Accessors
11280  */
11281
11282 /**
11283  * gtk_tree_view_get_model:
11284  * @tree_view: a #GtkTreeView
11285  *
11286  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
11287  * model is unset.
11288  *
11289  * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
11290  **/
11291 GtkTreeModel *
11292 gtk_tree_view_get_model (GtkTreeView *tree_view)
11293 {
11294   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11295
11296   return tree_view->priv->model;
11297 }
11298
11299 /**
11300  * gtk_tree_view_set_model:
11301  * @tree_view: A #GtkTreeView.
11302  * @model: (allow-none): The model.
11303  *
11304  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
11305  * set, it will remove it before setting the new model.  If @model is %NULL,
11306  * then it will unset the old model.
11307  **/
11308 void
11309 gtk_tree_view_set_model (GtkTreeView  *tree_view,
11310                          GtkTreeModel *model)
11311 {
11312   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11313   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
11314
11315   if (model == tree_view->priv->model)
11316     return;
11317
11318   if (tree_view->priv->scroll_to_path)
11319     {
11320       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11321       tree_view->priv->scroll_to_path = NULL;
11322     }
11323
11324   if (tree_view->priv->rubber_band_status)
11325     gtk_tree_view_stop_rubber_band (tree_view);
11326
11327   if (tree_view->priv->model)
11328     {
11329       GList *tmplist = tree_view->priv->columns;
11330
11331       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
11332       gtk_tree_view_stop_editing (tree_view, TRUE);
11333
11334       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11335                                             gtk_tree_view_row_changed,
11336                                             tree_view);
11337       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11338                                             gtk_tree_view_row_inserted,
11339                                             tree_view);
11340       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11341                                             gtk_tree_view_row_has_child_toggled,
11342                                             tree_view);
11343       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11344                                             gtk_tree_view_row_deleted,
11345                                             tree_view);
11346       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
11347                                             gtk_tree_view_rows_reordered,
11348                                             tree_view);
11349
11350       for (; tmplist; tmplist = tmplist->next)
11351         _gtk_tree_view_column_unset_model (tmplist->data,
11352                                            tree_view->priv->model);
11353
11354       if (tree_view->priv->tree)
11355         gtk_tree_view_free_rbtree (tree_view);
11356
11357       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
11358       tree_view->priv->drag_dest_row = NULL;
11359       gtk_tree_row_reference_free (tree_view->priv->anchor);
11360       tree_view->priv->anchor = NULL;
11361       gtk_tree_row_reference_free (tree_view->priv->top_row);
11362       tree_view->priv->top_row = NULL;
11363       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11364       tree_view->priv->scroll_to_path = NULL;
11365
11366       tree_view->priv->scroll_to_column = NULL;
11367
11368       g_object_unref (tree_view->priv->model);
11369
11370       tree_view->priv->search_column = -1;
11371       tree_view->priv->fixed_height_check = 0;
11372       tree_view->priv->fixed_height = -1;
11373       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
11374       tree_view->priv->last_button_x = -1;
11375       tree_view->priv->last_button_y = -1;
11376     }
11377
11378   tree_view->priv->model = model;
11379
11380   if (tree_view->priv->model)
11381     {
11382       gint i;
11383       GtkTreePath *path;
11384       GtkTreeIter iter;
11385       GtkTreeModelFlags flags;
11386
11387       if (tree_view->priv->search_column == -1)
11388         {
11389           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
11390             {
11391               GType type = gtk_tree_model_get_column_type (model, i);
11392
11393               if (g_value_type_transformable (type, G_TYPE_STRING))
11394                 {
11395                   tree_view->priv->search_column = i;
11396                   break;
11397                 }
11398             }
11399         }
11400
11401       g_object_ref (tree_view->priv->model);
11402       g_signal_connect (tree_view->priv->model,
11403                         "row-changed",
11404                         G_CALLBACK (gtk_tree_view_row_changed),
11405                         tree_view);
11406       g_signal_connect (tree_view->priv->model,
11407                         "row-inserted",
11408                         G_CALLBACK (gtk_tree_view_row_inserted),
11409                         tree_view);
11410       g_signal_connect (tree_view->priv->model,
11411                         "row-has-child-toggled",
11412                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
11413                         tree_view);
11414       g_signal_connect (tree_view->priv->model,
11415                         "row-deleted",
11416                         G_CALLBACK (gtk_tree_view_row_deleted),
11417                         tree_view);
11418       g_signal_connect (tree_view->priv->model,
11419                         "rows-reordered",
11420                         G_CALLBACK (gtk_tree_view_rows_reordered),
11421                         tree_view);
11422
11423       flags = gtk_tree_model_get_flags (tree_view->priv->model);
11424       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
11425         tree_view->priv->is_list = TRUE;
11426       else
11427         tree_view->priv->is_list = FALSE;
11428
11429       path = gtk_tree_path_new_first ();
11430       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
11431         {
11432           tree_view->priv->tree = _gtk_rbtree_new ();
11433           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
11434           _gtk_tree_view_accessible_add (tree_view, tree_view->priv->tree, NULL);
11435         }
11436       gtk_tree_path_free (path);
11437
11438       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
11439       install_presize_handler (tree_view);
11440     }
11441
11442   gtk_tree_view_real_set_cursor (tree_view, NULL, CURSOR_INVALID);
11443
11444   g_object_notify (G_OBJECT (tree_view), "model");
11445
11446   if (tree_view->priv->selection)
11447   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
11448
11449   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11450     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11451 }
11452
11453 /**
11454  * gtk_tree_view_get_selection:
11455  * @tree_view: A #GtkTreeView.
11456  *
11457  * Gets the #GtkTreeSelection associated with @tree_view.
11458  *
11459  * Return value: (transfer none): A #GtkTreeSelection object.
11460  **/
11461 GtkTreeSelection *
11462 gtk_tree_view_get_selection (GtkTreeView *tree_view)
11463 {
11464   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11465
11466   return tree_view->priv->selection;
11467 }
11468
11469 /**
11470  * gtk_tree_view_get_hadjustment:
11471  * @tree_view: A #GtkTreeView
11472  *
11473  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
11474  *
11475  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11476  *     if none is currently being used.
11477  *
11478  * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment()
11479  **/
11480 GtkAdjustment *
11481 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
11482 {
11483   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11484
11485   return gtk_tree_view_do_get_hadjustment (tree_view);
11486 }
11487
11488 static GtkAdjustment *
11489 gtk_tree_view_do_get_hadjustment (GtkTreeView *tree_view)
11490 {
11491   return tree_view->priv->hadjustment;
11492 }
11493
11494 /**
11495  * gtk_tree_view_set_hadjustment:
11496  * @tree_view: A #GtkTreeView
11497  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11498  *
11499  * Sets the #GtkAdjustment for the current horizontal aspect.
11500  *
11501  * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment()
11502  **/
11503 void
11504 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
11505                                GtkAdjustment *adjustment)
11506 {
11507   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11508   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11509
11510   gtk_tree_view_do_set_hadjustment (tree_view, adjustment);
11511 }
11512
11513 static void
11514 gtk_tree_view_do_set_hadjustment (GtkTreeView   *tree_view,
11515                                   GtkAdjustment *adjustment)
11516 {
11517   GtkTreeViewPrivate *priv = tree_view->priv;
11518
11519   if (adjustment && priv->hadjustment == adjustment)
11520     return;
11521
11522   if (priv->hadjustment != NULL)
11523     {
11524       g_signal_handlers_disconnect_by_func (priv->hadjustment,
11525                                             gtk_tree_view_adjustment_changed,
11526                                             tree_view);
11527       g_object_unref (priv->hadjustment);
11528     }
11529
11530   if (adjustment == NULL)
11531     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11532                                      0.0, 0.0, 0.0);
11533
11534   g_signal_connect (adjustment, "value-changed",
11535                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11536   priv->hadjustment = g_object_ref_sink (adjustment);
11537   /* FIXME: Adjustment should probably be populated here with fresh values, but
11538    * internal details are too complicated for me to decipher right now.
11539    */
11540   gtk_tree_view_adjustment_changed (NULL, tree_view);
11541
11542   g_object_notify (G_OBJECT (tree_view), "hadjustment");
11543 }
11544
11545 /**
11546  * gtk_tree_view_get_vadjustment:
11547  * @tree_view: A #GtkTreeView
11548  *
11549  * Gets the #GtkAdjustment currently being used for the vertical aspect.
11550  *
11551  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
11552  *     if none is currently being used.
11553  *
11554  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
11555  **/
11556 GtkAdjustment *
11557 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
11558 {
11559   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11560
11561   return gtk_tree_view_do_get_vadjustment (tree_view);
11562 }
11563
11564 static GtkAdjustment *
11565 gtk_tree_view_do_get_vadjustment (GtkTreeView *tree_view)
11566 {
11567   return tree_view->priv->vadjustment;
11568 }
11569
11570 /**
11571  * gtk_tree_view_set_vadjustment:
11572  * @tree_view: A #GtkTreeView
11573  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
11574  *
11575  * Sets the #GtkAdjustment for the current vertical aspect.
11576  *
11577  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
11578  **/
11579 void
11580 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
11581                                GtkAdjustment *adjustment)
11582 {
11583   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11584   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
11585
11586   gtk_tree_view_do_set_vadjustment (tree_view, adjustment);
11587 }
11588
11589 static void
11590 gtk_tree_view_do_set_vadjustment (GtkTreeView   *tree_view,
11591                                   GtkAdjustment *adjustment)
11592 {
11593   GtkTreeViewPrivate *priv = tree_view->priv;
11594
11595   if (adjustment && priv->vadjustment == adjustment)
11596     return;
11597
11598   if (priv->vadjustment != NULL)
11599     {
11600       g_signal_handlers_disconnect_by_func (priv->vadjustment,
11601                                             gtk_tree_view_adjustment_changed,
11602                                             tree_view);
11603       g_object_unref (priv->vadjustment);
11604     }
11605
11606   if (adjustment == NULL)
11607     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
11608                                      0.0, 0.0, 0.0);
11609
11610   g_signal_connect (adjustment, "value-changed",
11611                     G_CALLBACK (gtk_tree_view_adjustment_changed), tree_view);
11612   priv->vadjustment = g_object_ref_sink (adjustment);
11613   /* FIXME: Adjustment should probably be populated here with fresh values, but
11614    * internal details are too complicated for me to decipher right now.
11615    */
11616   gtk_tree_view_adjustment_changed (NULL, tree_view);
11617   g_object_notify (G_OBJECT (tree_view), "vadjustment");
11618 }
11619
11620 /* Column and header operations */
11621
11622 /**
11623  * gtk_tree_view_get_headers_visible:
11624  * @tree_view: A #GtkTreeView.
11625  *
11626  * Returns %TRUE if the headers on the @tree_view are visible.
11627  *
11628  * Return value: Whether the headers are visible or not.
11629  **/
11630 gboolean
11631 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
11632 {
11633   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11634
11635   return tree_view->priv->headers_visible;
11636 }
11637
11638 /**
11639  * gtk_tree_view_set_headers_visible:
11640  * @tree_view: A #GtkTreeView.
11641  * @headers_visible: %TRUE if the headers are visible
11642  *
11643  * Sets the visibility state of the headers.
11644  **/
11645 void
11646 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
11647                                    gboolean     headers_visible)
11648 {
11649   gint x, y;
11650   GList *list;
11651   GtkTreeViewColumn *column;
11652   GtkAllocation allocation;
11653   GtkWidget *button;
11654
11655   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11656
11657   headers_visible = !! headers_visible;
11658
11659   if (tree_view->priv->headers_visible == headers_visible)
11660     return;
11661
11662   tree_view->priv->headers_visible = headers_visible == TRUE;
11663
11664   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11665     {
11666       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
11667       if (headers_visible)
11668         {
11669           gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11670           gdk_window_move_resize (tree_view->priv->bin_window,
11671                                   x, y  + gtk_tree_view_get_effective_header_height (tree_view),
11672                                   tree_view->priv->width, allocation.height -  + gtk_tree_view_get_effective_header_height (tree_view));
11673
11674           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
11675             gtk_tree_view_map_buttons (tree_view);
11676         }
11677       else
11678         {
11679           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
11680
11681           for (list = tree_view->priv->columns; list; list = list->next)
11682             {
11683               column = list->data;
11684               button = gtk_tree_view_column_get_button (column);
11685
11686               gtk_widget_hide (button);
11687               gtk_widget_unmap (button);
11688             }
11689           gdk_window_hide (tree_view->priv->header_window);
11690         }
11691     }
11692
11693   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11694   gtk_adjustment_configure (tree_view->priv->vadjustment,
11695                             gtk_adjustment_get_value (tree_view->priv->vadjustment),
11696                             0,
11697                             tree_view->priv->height,
11698                             gtk_adjustment_get_step_increment (tree_view->priv->vadjustment),
11699                             (allocation.height - gtk_tree_view_get_effective_header_height (tree_view)) / 2,
11700                             allocation.height - gtk_tree_view_get_effective_header_height (tree_view));
11701
11702   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11703
11704   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11705 }
11706
11707 /**
11708  * gtk_tree_view_columns_autosize:
11709  * @tree_view: A #GtkTreeView.
11710  *
11711  * Resizes all columns to their optimal width. Only works after the
11712  * treeview has been realized.
11713  **/
11714 void
11715 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11716 {
11717   gboolean dirty = FALSE;
11718   GList *list;
11719   GtkTreeViewColumn *column;
11720
11721   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11722
11723   for (list = tree_view->priv->columns; list; list = list->next)
11724     {
11725       column = list->data;
11726       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11727         continue;
11728       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11729       dirty = TRUE;
11730     }
11731
11732   if (dirty)
11733     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11734 }
11735
11736 /**
11737  * gtk_tree_view_set_headers_clickable:
11738  * @tree_view: A #GtkTreeView.
11739  * @setting: %TRUE if the columns are clickable.
11740  *
11741  * Allow the column title buttons to be clicked.
11742  **/
11743 void
11744 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11745                                      gboolean   setting)
11746 {
11747   GList *list;
11748
11749   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11750
11751   for (list = tree_view->priv->columns; list; list = list->next)
11752     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11753
11754   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11755 }
11756
11757
11758 /**
11759  * gtk_tree_view_get_headers_clickable:
11760  * @tree_view: A #GtkTreeView.
11761  *
11762  * Returns whether all header columns are clickable.
11763  *
11764  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11765  *
11766  * Since: 2.10
11767  **/
11768 gboolean
11769 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11770 {
11771   GList *list;
11772
11773   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11774
11775   for (list = tree_view->priv->columns; list; list = list->next)
11776     if (!gtk_tree_view_column_get_clickable (GTK_TREE_VIEW_COLUMN (list->data)))
11777       return FALSE;
11778
11779   return TRUE;
11780 }
11781
11782 /**
11783  * gtk_tree_view_set_rules_hint:
11784  * @tree_view: a #GtkTreeView
11785  * @setting: %TRUE if the tree requires reading across rows
11786  *
11787  * This function tells GTK+ that the user interface for your
11788  * application requires users to read across tree rows and associate
11789  * cells with one another. By default, GTK+ will then render the tree
11790  * with alternating row colors. Do <emphasis>not</emphasis> use it
11791  * just because you prefer the appearance of the ruled tree; that's a
11792  * question for the theme. Some themes will draw tree rows in
11793  * alternating colors even when rules are turned off, and users who
11794  * prefer that appearance all the time can choose those themes. You
11795  * should call this function only as a <emphasis>semantic</emphasis>
11796  * hint to the theme engine that your tree makes alternating colors
11797  * useful from a functional standpoint (since it has lots of columns,
11798  * generally).
11799  *
11800  **/
11801 void
11802 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11803                               gboolean      setting)
11804 {
11805   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11806
11807   setting = setting != FALSE;
11808
11809   if (tree_view->priv->has_rules != setting)
11810     {
11811       tree_view->priv->has_rules = setting;
11812       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11813     }
11814
11815   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11816 }
11817
11818 /**
11819  * gtk_tree_view_get_rules_hint:
11820  * @tree_view: a #GtkTreeView
11821  *
11822  * Gets the setting set by gtk_tree_view_set_rules_hint().
11823  *
11824  * Return value: %TRUE if rules are useful for the user of this tree
11825  **/
11826 gboolean
11827 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11828 {
11829   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11830
11831   return tree_view->priv->has_rules;
11832 }
11833
11834
11835 /**
11836  * gtk_tree_view_set_activate_on_single_click:
11837  * @tree_view: a #GtkTreeView
11838  * @single: %TRUE to emit row-activated on a single click
11839  *
11840  * Cause the #GtkTreeView::row-activated signal to be emitted
11841  * on a single click instead of a double click.
11842  *
11843  * Since: 3.8
11844  **/
11845 void
11846 gtk_tree_view_set_activate_on_single_click (GtkTreeView *tree_view,
11847                                             gboolean     single)
11848 {
11849   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11850
11851   single = single != FALSE;
11852
11853   if (tree_view->priv->activate_on_single_click == single)
11854     return;
11855
11856   tree_view->priv->activate_on_single_click = single;
11857   g_object_notify (G_OBJECT (tree_view), "activate-on-single-click");
11858 }
11859
11860 /**
11861  * gtk_tree_view_get_activate_on_single_click:
11862  * @tree_view: a #GtkTreeView
11863  *
11864  * Gets the setting set by gtk_tree_view_set_activate_on_single_click().
11865  *
11866  * Return value: %TRUE if row-activated will be emitted on a single click
11867  *
11868  * Since: 3.8
11869  **/
11870 gboolean
11871 gtk_tree_view_get_activate_on_single_click (GtkTreeView *tree_view)
11872 {
11873   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11874
11875   return tree_view->priv->activate_on_single_click;
11876 }
11877
11878 /* Public Column functions
11879  */
11880
11881 /**
11882  * gtk_tree_view_append_column:
11883  * @tree_view: A #GtkTreeView.
11884  * @column: The #GtkTreeViewColumn to add.
11885  *
11886  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11887  * mode enabled, then @column must have its "sizing" property set to be
11888  * GTK_TREE_VIEW_COLUMN_FIXED.
11889  *
11890  * Return value: The number of columns in @tree_view after appending.
11891  **/
11892 gint
11893 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11894                              GtkTreeViewColumn *column)
11895 {
11896   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11897   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11898   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
11899
11900   return gtk_tree_view_insert_column (tree_view, column, -1);
11901 }
11902
11903 void
11904 _gtk_tree_view_reset_header_styles (GtkTreeView *tree_view)
11905 {
11906   GList *columns;
11907
11908   for (columns = tree_view->priv->columns; columns; columns = columns->next)
11909     {
11910       GtkTreeViewColumn *column = columns->data;
11911       GtkWidget *header_widget;
11912
11913       if (!gtk_tree_view_column_get_visible (column))
11914         continue;
11915
11916       header_widget = gtk_tree_view_column_get_widget (column);
11917
11918       if (!header_widget)
11919         header_widget = gtk_tree_view_column_get_button (column);
11920
11921       _gtk_widget_invalidate_style_context (header_widget, GTK_CSS_CHANGE_PARENT_REGION);
11922     }
11923 }
11924
11925
11926 /**
11927  * gtk_tree_view_remove_column:
11928  * @tree_view: A #GtkTreeView.
11929  * @column: The #GtkTreeViewColumn to remove.
11930  *
11931  * Removes @column from @tree_view.
11932  *
11933  * Return value: The number of columns in @tree_view after removing.
11934  **/
11935 gint
11936 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11937                              GtkTreeViewColumn *column)
11938 {
11939   guint position;
11940
11941   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11942   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11943   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view), -1);
11944
11945   if (tree_view->priv->focus_column == column)
11946     _gtk_tree_view_set_focus_column (tree_view, NULL);
11947
11948   if (tree_view->priv->edited_column == column)
11949     {
11950       gtk_tree_view_stop_editing (tree_view, TRUE);
11951
11952       /* no need to, but just to be sure ... */
11953       tree_view->priv->edited_column = NULL;
11954     }
11955
11956   if (tree_view->priv->expander_column == column)
11957     tree_view->priv->expander_column = NULL;
11958
11959   g_signal_handlers_disconnect_by_func (column,
11960                                         G_CALLBACK (column_sizing_notify),
11961                                         tree_view);
11962
11963   _gtk_tree_view_column_unset_tree_view (column);
11964
11965   position = g_list_index (tree_view->priv->columns, column);
11966
11967   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11968   tree_view->priv->n_columns--;
11969
11970   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11971     {
11972       GList *list;
11973
11974       _gtk_tree_view_column_unrealize_button (column);
11975       for (list = tree_view->priv->columns; list; list = list->next)
11976         {
11977           GtkTreeViewColumn *tmp_column;
11978
11979           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11980           if (gtk_tree_view_column_get_visible (tmp_column))
11981             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
11982         }
11983
11984       if (tree_view->priv->n_columns == 0 &&
11985           gtk_tree_view_get_headers_visible (tree_view))
11986         gdk_window_hide (tree_view->priv->header_window);
11987
11988       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11989     }
11990
11991   _gtk_tree_view_reset_header_styles (tree_view);
11992
11993   _gtk_tree_view_accessible_remove_column (tree_view, column, position);
11994
11995   g_object_unref (column);
11996   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11997
11998   return tree_view->priv->n_columns;
11999 }
12000
12001 /**
12002  * gtk_tree_view_insert_column:
12003  * @tree_view: A #GtkTreeView.
12004  * @column: The #GtkTreeViewColumn to be inserted.
12005  * @position: The position to insert @column in.
12006  *
12007  * This inserts the @column into the @tree_view at @position.  If @position is
12008  * -1, then the column is inserted at the end. If @tree_view has
12009  * "fixed_height" mode enabled, then @column must have its "sizing" property
12010  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
12011  *
12012  * Return value: The number of columns in @tree_view after insertion.
12013  **/
12014 gint
12015 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
12016                              GtkTreeViewColumn *column,
12017                              gint               position)
12018 {
12019   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12020   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
12021   g_return_val_if_fail (gtk_tree_view_column_get_tree_view (column) == NULL, -1);
12022
12023   if (tree_view->priv->fixed_height_mode)
12024     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
12025                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
12026
12027   if (position < 0 || position > tree_view->priv->n_columns)
12028     position = tree_view->priv->n_columns;
12029
12030   g_object_ref_sink (column);
12031
12032   if (tree_view->priv->n_columns == 0 &&
12033       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
12034       gtk_tree_view_get_headers_visible (tree_view))
12035     {
12036       gdk_window_show (tree_view->priv->header_window);
12037     }
12038
12039   g_signal_connect (column, "notify::sizing",
12040                     G_CALLBACK (column_sizing_notify), tree_view);
12041
12042   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
12043                                             column, position);
12044   tree_view->priv->n_columns++;
12045
12046   _gtk_tree_view_column_set_tree_view (column, tree_view);
12047
12048   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12049     {
12050       GList *list;
12051
12052       _gtk_tree_view_column_realize_button (column);
12053
12054       for (list = tree_view->priv->columns; list; list = list->next)
12055         {
12056           column = GTK_TREE_VIEW_COLUMN (list->data);
12057           if (gtk_tree_view_column_get_visible (column))
12058             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12059         }
12060       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12061     }
12062
12063   _gtk_tree_view_reset_header_styles (tree_view);
12064
12065   _gtk_tree_view_accessible_add_column (tree_view, column, position);
12066
12067   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12068
12069   return tree_view->priv->n_columns;
12070 }
12071
12072 /**
12073  * gtk_tree_view_insert_column_with_attributes:
12074  * @tree_view: A #GtkTreeView
12075  * @position: The position to insert the new column in
12076  * @title: The title to set the header to
12077  * @cell: The #GtkCellRenderer
12078  * @...: A %NULL-terminated list of attributes
12079  *
12080  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
12081  * @position.  If @position is -1, then the newly created column is inserted at
12082  * the end.  The column is initialized with the attributes given. If @tree_view
12083  * has "fixed_height" mode enabled, then the new column will have its sizing
12084  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12085  *
12086  * Return value: The number of columns in @tree_view after insertion.
12087  **/
12088 gint
12089 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
12090                                              gint             position,
12091                                              const gchar     *title,
12092                                              GtkCellRenderer *cell,
12093                                              ...)
12094 {
12095   GtkTreeViewColumn *column;
12096   gchar *attribute;
12097   va_list args;
12098   gint column_id;
12099
12100   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12101
12102   column = gtk_tree_view_column_new ();
12103   if (tree_view->priv->fixed_height_mode)
12104     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12105
12106   gtk_tree_view_column_set_title (column, title);
12107   gtk_tree_view_column_pack_start (column, cell, TRUE);
12108
12109   va_start (args, cell);
12110
12111   attribute = va_arg (args, gchar *);
12112
12113   while (attribute != NULL)
12114     {
12115       column_id = va_arg (args, gint);
12116       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
12117       attribute = va_arg (args, gchar *);
12118     }
12119
12120   va_end (args);
12121
12122   return gtk_tree_view_insert_column (tree_view, column, position);
12123 }
12124
12125 /**
12126  * gtk_tree_view_insert_column_with_data_func:
12127  * @tree_view: a #GtkTreeView
12128  * @position: Position to insert, -1 for append
12129  * @title: column title
12130  * @cell: cell renderer for column
12131  * @func: function to set attributes of cell renderer
12132  * @data: data for @func
12133  * @dnotify: destroy notifier for @data
12134  *
12135  * Convenience function that inserts a new column into the #GtkTreeView
12136  * with the given cell renderer and a #GtkTreeCellDataFunc to set cell renderer
12137  * attributes (normally using data from the model). See also
12138  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
12139  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
12140  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
12141  *
12142  * Return value: number of columns in the tree view post-insert
12143  **/
12144 gint
12145 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
12146                                              gint                       position,
12147                                              const gchar               *title,
12148                                              GtkCellRenderer           *cell,
12149                                              GtkTreeCellDataFunc        func,
12150                                              gpointer                   data,
12151                                              GDestroyNotify             dnotify)
12152 {
12153   GtkTreeViewColumn *column;
12154
12155   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
12156
12157   column = gtk_tree_view_column_new ();
12158   if (tree_view->priv->fixed_height_mode)
12159     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
12160
12161   gtk_tree_view_column_set_title (column, title);
12162   gtk_tree_view_column_pack_start (column, cell, TRUE);
12163   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
12164
12165   return gtk_tree_view_insert_column (tree_view, column, position);
12166 }
12167
12168 /**
12169  * gtk_tree_view_get_n_columns:
12170  * @tree_view: a #GtkTreeView
12171  *
12172  * Queries the number of columns in the given @tree_view.
12173  *
12174  * Returns: The number of columns in the @tree_view
12175  *
12176  * Since: 3.4
12177  **/
12178 guint
12179 gtk_tree_view_get_n_columns (GtkTreeView *tree_view)
12180 {
12181   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
12182
12183   return tree_view->priv->n_columns;
12184 }
12185
12186 /**
12187  * gtk_tree_view_get_column:
12188  * @tree_view: A #GtkTreeView.
12189  * @n: The position of the column, counting from 0.
12190  *
12191  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
12192  *
12193  * Return value: (transfer none): The #GtkTreeViewColumn, or %NULL if the
12194  *     position is outside the range of columns.
12195  **/
12196 GtkTreeViewColumn *
12197 gtk_tree_view_get_column (GtkTreeView *tree_view,
12198                           gint         n)
12199 {
12200   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12201
12202   if (n < 0 || n >= tree_view->priv->n_columns)
12203     return NULL;
12204
12205   if (tree_view->priv->columns == NULL)
12206     return NULL;
12207
12208   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
12209 }
12210
12211 /**
12212  * gtk_tree_view_get_columns:
12213  * @tree_view: A #GtkTreeView
12214  *
12215  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
12216  * The returned list must be freed with g_list_free ().
12217  *
12218  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
12219  **/
12220 GList *
12221 gtk_tree_view_get_columns (GtkTreeView *tree_view)
12222 {
12223   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12224
12225   return g_list_copy (tree_view->priv->columns);
12226 }
12227
12228 /**
12229  * gtk_tree_view_move_column_after:
12230  * @tree_view: A #GtkTreeView
12231  * @column: The #GtkTreeViewColumn to be moved.
12232  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
12233  *
12234  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
12235  * @column is placed in the first position.
12236  **/
12237 void
12238 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
12239                                  GtkTreeViewColumn *column,
12240                                  GtkTreeViewColumn *base_column)
12241 {
12242   GList *column_list_el, *base_el = NULL;
12243
12244   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12245
12246   column_list_el = g_list_find (tree_view->priv->columns, column);
12247   g_return_if_fail (column_list_el != NULL);
12248
12249   if (base_column)
12250     {
12251       base_el = g_list_find (tree_view->priv->columns, base_column);
12252       g_return_if_fail (base_el != NULL);
12253     }
12254
12255   if (column_list_el->prev == base_el)
12256     return;
12257
12258   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
12259   if (base_el == NULL)
12260     {
12261       column_list_el->prev = NULL;
12262       column_list_el->next = tree_view->priv->columns;
12263       if (column_list_el->next)
12264         column_list_el->next->prev = column_list_el;
12265       tree_view->priv->columns = column_list_el;
12266     }
12267   else
12268     {
12269       column_list_el->prev = base_el;
12270       column_list_el->next = base_el->next;
12271       if (column_list_el->next)
12272         column_list_el->next->prev = column_list_el;
12273       base_el->next = column_list_el;
12274     }
12275
12276   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
12277     {
12278       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12279       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
12280     }
12281
12282   _gtk_tree_view_reset_header_styles (tree_view);
12283
12284   _gtk_tree_view_accessible_reorder_column (tree_view, column);
12285
12286   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
12287 }
12288
12289 /**
12290  * gtk_tree_view_set_expander_column:
12291  * @tree_view: A #GtkTreeView
12292  * @column: %NULL, or the column to draw the expander arrow at.
12293  *
12294  * Sets the column to draw the expander arrow at. It must be in @tree_view.
12295  * If @column is %NULL, then the expander arrow is always at the first
12296  * visible column.
12297  *
12298  * If you do not want expander arrow to appear in your tree, set the
12299  * expander column to a hidden column.
12300  **/
12301 void
12302 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
12303                                    GtkTreeViewColumn *column)
12304 {
12305   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12306   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12307   g_return_if_fail (column == NULL || gtk_tree_view_column_get_tree_view (column) == GTK_WIDGET (tree_view));
12308
12309   if (tree_view->priv->expander_column != column)
12310     {
12311       tree_view->priv->expander_column = column;
12312       g_object_notify (G_OBJECT (tree_view), "expander-column");
12313     }
12314 }
12315
12316 /**
12317  * gtk_tree_view_get_expander_column:
12318  * @tree_view: A #GtkTreeView
12319  *
12320  * Returns the column that is the current expander column.
12321  * This column has the expander arrow drawn next to it.
12322  *
12323  * Return value: (transfer none): The expander column.
12324  **/
12325 GtkTreeViewColumn *
12326 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
12327 {
12328   GList *list;
12329
12330   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12331
12332   for (list = tree_view->priv->columns; list; list = list->next)
12333     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
12334       return (GtkTreeViewColumn *) list->data;
12335   return NULL;
12336 }
12337
12338
12339 /**
12340  * gtk_tree_view_set_column_drag_function:
12341  * @tree_view: A #GtkTreeView.
12342  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
12343  * @user_data: (allow-none): User data to be passed to @func, or %NULL
12344  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
12345  *
12346  * Sets a user function for determining where a column may be dropped when
12347  * dragged.  This function is called on every column pair in turn at the
12348  * beginning of a column drag to determine where a drop can take place.  The
12349  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
12350  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
12351  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
12352  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
12353  * @tree_view reverts to the default behavior of allowing all columns to be
12354  * dropped everywhere.
12355  **/
12356 void
12357 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
12358                                         GtkTreeViewColumnDropFunc  func,
12359                                         gpointer                   user_data,
12360                                         GDestroyNotify             destroy)
12361 {
12362   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12363
12364   if (tree_view->priv->column_drop_func_data_destroy)
12365     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
12366
12367   tree_view->priv->column_drop_func = func;
12368   tree_view->priv->column_drop_func_data = user_data;
12369   tree_view->priv->column_drop_func_data_destroy = destroy;
12370 }
12371
12372 /**
12373  * gtk_tree_view_scroll_to_point:
12374  * @tree_view: a #GtkTreeView
12375  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
12376  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
12377  *
12378  * Scrolls the tree view such that the top-left corner of the visible
12379  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
12380  * in tree coordinates.  The @tree_view must be realized before
12381  * this function is called.  If it isn't, you probably want to be
12382  * using gtk_tree_view_scroll_to_cell().
12383  *
12384  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
12385  **/
12386 void
12387 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
12388                                gint         tree_x,
12389                                gint         tree_y)
12390 {
12391   GtkAdjustment *hadj;
12392   GtkAdjustment *vadj;
12393
12394   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12395   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
12396
12397   hadj = tree_view->priv->hadjustment;
12398   vadj = tree_view->priv->vadjustment;
12399
12400   if (tree_x != -1)
12401     gtk_adjustment_set_value (hadj, tree_x);
12402   if (tree_y != -1)
12403     gtk_adjustment_set_value (vadj, tree_y);
12404 }
12405
12406 /**
12407  * gtk_tree_view_scroll_to_cell:
12408  * @tree_view: A #GtkTreeView.
12409  * @path: (allow-none): The path of the row to move to, or %NULL.
12410  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
12411  * @use_align: whether to use alignment arguments, or %FALSE.
12412  * @row_align: The vertical alignment of the row specified by @path.
12413  * @col_align: The horizontal alignment of the column specified by @column.
12414  *
12415  * Moves the alignments of @tree_view to the position specified by @column and
12416  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
12417  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
12418  * or @path need to be non-%NULL.  @row_align determines where the row is
12419  * placed, and @col_align determines where @column is placed.  Both are expected
12420  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
12421  * right/bottom alignment, 0.5 means center.
12422  *
12423  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
12424  * tree does the minimum amount of work to scroll the cell onto the screen.
12425  * This means that the cell will be scrolled to the edge closest to its current
12426  * position.  If the cell is currently visible on the screen, nothing is done.
12427  *
12428  * This function only works if the model is set, and @path is a valid row on the
12429  * model.  If the model changes before the @tree_view is realized, the centered
12430  * path will be modified to reflect this change.
12431  **/
12432 void
12433 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
12434                               GtkTreePath       *path,
12435                               GtkTreeViewColumn *column,
12436                               gboolean           use_align,
12437                               gfloat             row_align,
12438                               gfloat             col_align)
12439 {
12440   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12441   g_return_if_fail (tree_view->priv->model != NULL);
12442   g_return_if_fail (tree_view->priv->tree != NULL);
12443   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
12444   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
12445   g_return_if_fail (path != NULL || column != NULL);
12446
12447 #if 0
12448   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
12449            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
12450 #endif
12451   row_align = CLAMP (row_align, 0.0, 1.0);
12452   col_align = CLAMP (col_align, 0.0, 1.0);
12453
12454
12455   /* Note: Despite the benefits that come from having one code path for the
12456    * scrolling code, we short-circuit validate_visible_area's immplementation as
12457    * it is much slower than just going to the point.
12458    */
12459   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
12460       !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
12461       _gtk_widget_get_alloc_needed (GTK_WIDGET (tree_view)) ||
12462       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
12463     {
12464       if (tree_view->priv->scroll_to_path)
12465         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
12466
12467       tree_view->priv->scroll_to_path = NULL;
12468       tree_view->priv->scroll_to_column = NULL;
12469
12470       if (path)
12471         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
12472       if (column)
12473         tree_view->priv->scroll_to_column = column;
12474       tree_view->priv->scroll_to_use_align = use_align;
12475       tree_view->priv->scroll_to_row_align = row_align;
12476       tree_view->priv->scroll_to_col_align = col_align;
12477
12478       install_presize_handler (tree_view);
12479     }
12480   else
12481     {
12482       GdkRectangle cell_rect;
12483       GdkRectangle vis_rect;
12484       gint dest_x, dest_y;
12485
12486       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
12487       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
12488
12489       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
12490
12491       dest_x = vis_rect.x;
12492       dest_y = vis_rect.y;
12493
12494       if (column)
12495         {
12496           if (use_align)
12497             {
12498               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
12499             }
12500           else
12501             {
12502               if (cell_rect.x < vis_rect.x)
12503                 dest_x = cell_rect.x;
12504               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
12505                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
12506             }
12507         }
12508
12509       if (path)
12510         {
12511           if (use_align)
12512             {
12513               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
12514               dest_y = MAX (dest_y, 0);
12515             }
12516           else
12517             {
12518               if (cell_rect.y < vis_rect.y)
12519                 dest_y = cell_rect.y;
12520               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
12521                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
12522             }
12523         }
12524
12525       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
12526     }
12527 }
12528
12529 /**
12530  * gtk_tree_view_row_activated:
12531  * @tree_view: A #GtkTreeView
12532  * @path: The #GtkTreePath to be activated.
12533  * @column: The #GtkTreeViewColumn to be activated.
12534  *
12535  * Activates the cell determined by @path and @column.
12536  **/
12537 void
12538 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
12539                              GtkTreePath       *path,
12540                              GtkTreeViewColumn *column)
12541 {
12542   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12543
12544   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
12545 }
12546
12547
12548 static void
12549 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
12550                                           GtkRBNode *node,
12551                                           gpointer   data)
12552 {
12553   GtkTreeView *tree_view = data;
12554
12555   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
12556       node->children)
12557     {
12558       GtkTreePath *path;
12559       GtkTreeIter iter;
12560
12561       path = _gtk_tree_path_new_from_rbtree (tree, node);
12562       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12563
12564       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12565
12566       gtk_tree_path_free (path);
12567     }
12568
12569   if (node->children)
12570     _gtk_rbtree_traverse (node->children,
12571                           node->children->root,
12572                           G_PRE_ORDER,
12573                           gtk_tree_view_expand_all_emission_helper,
12574                           tree_view);
12575 }
12576
12577 /**
12578  * gtk_tree_view_expand_all:
12579  * @tree_view: A #GtkTreeView.
12580  *
12581  * Recursively expands all nodes in the @tree_view.
12582  **/
12583 void
12584 gtk_tree_view_expand_all (GtkTreeView *tree_view)
12585 {
12586   GtkTreePath *path;
12587   GtkRBTree *tree;
12588   GtkRBNode *node;
12589
12590   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12591
12592   if (tree_view->priv->tree == NULL)
12593     return;
12594
12595   path = gtk_tree_path_new_first ();
12596   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12597
12598   while (node)
12599     {
12600       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
12601       node = _gtk_rbtree_next (tree, node);
12602       gtk_tree_path_next (path);
12603   }
12604
12605   gtk_tree_path_free (path);
12606 }
12607
12608 /**
12609  * gtk_tree_view_collapse_all:
12610  * @tree_view: A #GtkTreeView.
12611  *
12612  * Recursively collapses all visible, expanded nodes in @tree_view.
12613  **/
12614 void
12615 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
12616 {
12617   GtkRBTree *tree;
12618   GtkRBNode *node;
12619   GtkTreePath *path;
12620   gint *indices;
12621
12622   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12623
12624   if (tree_view->priv->tree == NULL)
12625     return;
12626
12627   path = gtk_tree_path_new ();
12628   gtk_tree_path_down (path);
12629   indices = gtk_tree_path_get_indices (path);
12630
12631   tree = tree_view->priv->tree;
12632   node = _gtk_rbtree_first (tree);
12633
12634   while (node)
12635     {
12636       if (node->children)
12637         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12638       indices[0]++;
12639       node = _gtk_rbtree_next (tree, node);
12640     }
12641
12642   gtk_tree_path_free (path);
12643 }
12644
12645 /**
12646  * gtk_tree_view_expand_to_path:
12647  * @tree_view: A #GtkTreeView.
12648  * @path: path to a row.
12649  *
12650  * Expands the row at @path. This will also expand all parent rows of
12651  * @path as necessary.
12652  *
12653  * Since: 2.2
12654  **/
12655 void
12656 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
12657                               GtkTreePath *path)
12658 {
12659   gint i, depth;
12660   gint *indices;
12661   GtkTreePath *tmp;
12662
12663   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12664   g_return_if_fail (path != NULL);
12665
12666   depth = gtk_tree_path_get_depth (path);
12667   indices = gtk_tree_path_get_indices (path);
12668
12669   tmp = gtk_tree_path_new ();
12670   g_return_if_fail (tmp != NULL);
12671
12672   for (i = 0; i < depth; i++)
12673     {
12674       gtk_tree_path_append_index (tmp, indices[i]);
12675       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12676     }
12677
12678   gtk_tree_path_free (tmp);
12679 }
12680
12681 /* FIXME the bool return values for expand_row and collapse_row are
12682  * not analagous; they should be TRUE if the row had children and
12683  * was not already in the requested state.
12684  */
12685
12686
12687 static gboolean
12688 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12689                                GtkTreePath *path,
12690                                GtkRBTree   *tree,
12691                                GtkRBNode   *node,
12692                                gboolean     open_all,
12693                                gboolean     animate)
12694 {
12695   GtkTreeIter iter;
12696   GtkTreeIter temp;
12697   gboolean expand;
12698
12699   if (animate)
12700     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12701                   "gtk-enable-animations", &animate,
12702                   NULL);
12703
12704   remove_auto_expand_timeout (tree_view);
12705
12706   if (node->children && !open_all)
12707     return FALSE;
12708
12709   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12710     return FALSE;
12711
12712   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12713   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12714     return FALSE;
12715
12716
12717    if (node->children && open_all)
12718     {
12719       gboolean retval = FALSE;
12720       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12721
12722       gtk_tree_path_append_index (tmp_path, 0);
12723       tree = node->children;
12724       node = _gtk_rbtree_first (tree);
12725       /* try to expand the children */
12726       do
12727         {
12728          gboolean t;
12729          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12730                                             TRUE, animate);
12731          if (t)
12732            retval = TRUE;
12733
12734          gtk_tree_path_next (tmp_path);
12735          node = _gtk_rbtree_next (tree, node);
12736        }
12737       while (node != NULL);
12738
12739       gtk_tree_path_free (tmp_path);
12740
12741       return retval;
12742     }
12743
12744   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12745
12746   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12747     return FALSE;
12748
12749   if (expand)
12750     return FALSE;
12751
12752   node->children = _gtk_rbtree_new ();
12753   node->children->parent_tree = tree;
12754   node->children->parent_node = node;
12755
12756   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12757
12758   gtk_tree_view_build_tree (tree_view,
12759                             node->children,
12760                             &temp,
12761                             gtk_tree_path_get_depth (path) + 1,
12762                             open_all);
12763
12764   _gtk_tree_view_accessible_add (tree_view, node->children, NULL);
12765   _gtk_tree_view_accessible_add_state (tree_view,
12766                                        tree, node,
12767                                        GTK_CELL_RENDERER_EXPANDED);
12768
12769   install_presize_handler (tree_view);
12770
12771   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12772   if (open_all && node->children)
12773     {
12774       _gtk_rbtree_traverse (node->children,
12775                             node->children->root,
12776                             G_PRE_ORDER,
12777                             gtk_tree_view_expand_all_emission_helper,
12778                             tree_view);
12779     }
12780   return TRUE;
12781 }
12782
12783
12784 /**
12785  * gtk_tree_view_expand_row:
12786  * @tree_view: a #GtkTreeView
12787  * @path: path to a row
12788  * @open_all: whether to recursively expand, or just expand immediate children
12789  *
12790  * Opens the row so its children are visible.
12791  *
12792  * Return value: %TRUE if the row existed and had children
12793  **/
12794 gboolean
12795 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12796                           GtkTreePath *path,
12797                           gboolean     open_all)
12798 {
12799   GtkRBTree *tree;
12800   GtkRBNode *node;
12801
12802   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12803   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12804   g_return_val_if_fail (path != NULL, FALSE);
12805
12806   if (_gtk_tree_view_find_node (tree_view,
12807                                 path,
12808                                 &tree,
12809                                 &node))
12810     return FALSE;
12811
12812   if (tree != NULL)
12813     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12814   else
12815     return FALSE;
12816 }
12817
12818 static gboolean
12819 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12820                                  GtkTreePath *path,
12821                                  GtkRBTree   *tree,
12822                                  GtkRBNode   *node,
12823                                  gboolean     animate)
12824 {
12825   GtkTreeIter iter;
12826   GtkTreeIter children;
12827   gboolean collapse;
12828   gint x, y;
12829   GList *list;
12830   GdkWindow *child;
12831   gboolean selection_changed, cursor_changed;
12832
12833   if (animate)
12834     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12835                   "gtk-enable-animations", &animate,
12836                   NULL);
12837
12838   remove_auto_expand_timeout (tree_view);
12839
12840   if (node->children == NULL)
12841     return FALSE;
12842   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12843
12844   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12845
12846   if (collapse)
12847     return FALSE;
12848
12849   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12850    * a chance to prelight the correct node below */
12851
12852   if (tree_view->priv->prelight_tree)
12853     {
12854       GtkRBTree *parent_tree;
12855       GtkRBNode *parent_node;
12856
12857       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12858       parent_node = tree_view->priv->prelight_tree->parent_node;
12859       while (parent_tree)
12860         {
12861           if (parent_tree == tree && parent_node == node)
12862             {
12863               ensure_unprelighted (tree_view);
12864               break;
12865             }
12866           parent_node = parent_tree->parent_node;
12867           parent_tree = parent_tree->parent_tree;
12868         }
12869     }
12870
12871   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12872
12873   for (list = tree_view->priv->columns; list; list = list->next)
12874     {
12875       GtkTreeViewColumn *column = list->data;
12876
12877       if (gtk_tree_view_column_get_visible (column) == FALSE)
12878         continue;
12879       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12880         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12881     }
12882
12883   if (tree_view->priv->destroy_count_func)
12884     {
12885       GtkTreePath *child_path;
12886       gint child_count = 0;
12887       child_path = gtk_tree_path_copy (path);
12888       gtk_tree_path_down (child_path);
12889       if (node->children)
12890         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12891       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12892       gtk_tree_path_free (child_path);
12893     }
12894
12895   if (tree_view->priv->cursor_node)
12896     {
12897       cursor_changed = (node->children == tree_view->priv->cursor_tree)
12898                        || _gtk_rbtree_contains (node->children, tree_view->priv->cursor_tree);
12899     }
12900   else
12901     cursor_changed = FALSE;
12902
12903   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12904     {
12905       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12906       if (gtk_tree_path_is_ancestor (path, anchor_path))
12907         {
12908           gtk_tree_row_reference_free (tree_view->priv->anchor);
12909           tree_view->priv->anchor = NULL;
12910         }
12911       gtk_tree_path_free (anchor_path);
12912     }
12913
12914   selection_changed = gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children);
12915
12916   /* Stop a pending double click */
12917   tree_view->priv->last_button_x = -1;
12918   tree_view->priv->last_button_y = -1;
12919
12920   _gtk_tree_view_accessible_remove (tree_view, node->children, NULL);
12921   _gtk_tree_view_accessible_remove_state (tree_view,
12922                                           tree, node,
12923                                           GTK_CELL_RENDERER_EXPANDED);
12924
12925   _gtk_rbtree_remove (node->children);
12926
12927   if (cursor_changed)
12928     gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CURSOR_INVALID);
12929   if (selection_changed)
12930     g_signal_emit_by_name (tree_view->priv->selection, "changed");
12931
12932   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12933     {
12934       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12935     }
12936
12937   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12938
12939   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12940     {
12941       /* now that we've collapsed all rows, we want to try to set the prelight
12942        * again. To do this, we fake a motion event and send it to ourselves. */
12943
12944       child = gdk_window_get_device_position (gdk_window_get_parent (tree_view->priv->bin_window),
12945                                               gdk_device_manager_get_client_pointer (
12946                                                 gdk_display_get_device_manager (
12947                                                   gtk_widget_get_display (GTK_WIDGET (tree_view)))),
12948                                               &x, &y, NULL);
12949       if (child == tree_view->priv->bin_window)
12950         {
12951           GdkEventMotion event;
12952           gint child_x, child_y;
12953
12954           gdk_window_get_position (child, &child_x, &child_y);
12955
12956           event.window = tree_view->priv->bin_window;
12957           event.x = x - child_x;
12958           event.y = y - child_y;
12959
12960           /* despite the fact this isn't a real event, I'm almost positive it will
12961            * never trigger a drag event.  maybe_drag is the only function that uses
12962            * more than just event.x and event.y. */
12963           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
12964         }
12965     }
12966
12967   return TRUE;
12968 }
12969
12970 /**
12971  * gtk_tree_view_collapse_row:
12972  * @tree_view: a #GtkTreeView
12973  * @path: path to a row in the @tree_view
12974  *
12975  * Collapses a row (hides its child rows, if they exist).
12976  *
12977  * Return value: %TRUE if the row was collapsed.
12978  **/
12979 gboolean
12980 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
12981                             GtkTreePath *path)
12982 {
12983   GtkRBTree *tree;
12984   GtkRBNode *node;
12985
12986   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12987   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
12988   g_return_val_if_fail (path != NULL, FALSE);
12989
12990   if (_gtk_tree_view_find_node (tree_view,
12991                                 path,
12992                                 &tree,
12993                                 &node))
12994     return FALSE;
12995
12996   if (tree == NULL || node->children == NULL)
12997     return FALSE;
12998
12999   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
13000 }
13001
13002 static void
13003 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
13004                                         GtkRBTree              *tree,
13005                                         GtkTreePath            *path,
13006                                         GtkTreeViewMappingFunc  func,
13007                                         gpointer                user_data)
13008 {
13009   GtkRBNode *node;
13010
13011   if (tree == NULL || tree->root == NULL)
13012     return;
13013
13014   node = _gtk_rbtree_first (tree);
13015
13016   while (node)
13017     {
13018       if (node->children)
13019         {
13020           (* func) (tree_view, path, user_data);
13021           gtk_tree_path_down (path);
13022           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
13023           gtk_tree_path_up (path);
13024         }
13025       gtk_tree_path_next (path);
13026       node = _gtk_rbtree_next (tree, node);
13027     }
13028 }
13029
13030 /**
13031  * gtk_tree_view_map_expanded_rows:
13032  * @tree_view: A #GtkTreeView
13033  * @func: (scope call): A function to be called
13034  * @data: User data to be passed to the function.
13035  *
13036  * Calls @func on all expanded rows.
13037  **/
13038 void
13039 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
13040                                  GtkTreeViewMappingFunc  func,
13041                                  gpointer                user_data)
13042 {
13043   GtkTreePath *path;
13044
13045   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13046   g_return_if_fail (func != NULL);
13047
13048   path = gtk_tree_path_new_first ();
13049
13050   gtk_tree_view_map_expanded_rows_helper (tree_view,
13051                                           tree_view->priv->tree,
13052                                           path, func, user_data);
13053
13054   gtk_tree_path_free (path);
13055 }
13056
13057 /**
13058  * gtk_tree_view_row_expanded:
13059  * @tree_view: A #GtkTreeView.
13060  * @path: A #GtkTreePath to test expansion state.
13061  *
13062  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
13063  *
13064  * Return value: %TRUE if #path is expanded.
13065  **/
13066 gboolean
13067 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
13068                             GtkTreePath *path)
13069 {
13070   GtkRBTree *tree;
13071   GtkRBNode *node;
13072
13073   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13074   g_return_val_if_fail (path != NULL, FALSE);
13075
13076   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13077
13078   if (node == NULL)
13079     return FALSE;
13080
13081   return (node->children != NULL);
13082 }
13083
13084 /**
13085  * gtk_tree_view_get_reorderable:
13086  * @tree_view: a #GtkTreeView
13087  *
13088  * Retrieves whether the user can reorder the tree via drag-and-drop. See
13089  * gtk_tree_view_set_reorderable().
13090  *
13091  * Return value: %TRUE if the tree can be reordered.
13092  **/
13093 gboolean
13094 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
13095 {
13096   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13097
13098   return tree_view->priv->reorderable;
13099 }
13100
13101 /**
13102  * gtk_tree_view_set_reorderable:
13103  * @tree_view: A #GtkTreeView.
13104  * @reorderable: %TRUE, if the tree can be reordered.
13105  *
13106  * This function is a convenience function to allow you to reorder
13107  * models that support the #GtkTreeDragSourceIface and the
13108  * #GtkTreeDragDestIface.  Both #GtkTreeStore and #GtkListStore support
13109  * these.  If @reorderable is %TRUE, then the user can reorder the
13110  * model by dragging and dropping rows. The developer can listen to
13111  * these changes by connecting to the model's row_inserted and
13112  * row_deleted signals. The reordering is implemented by setting up
13113  * the tree view as a drag source and destination. Therefore, drag and
13114  * drop can not be used in a reorderable view for any other purpose.
13115  *
13116  * This function does not give you any degree of control over the order -- any
13117  * reordering is allowed.  If more control is needed, you should probably
13118  * handle drag and drop manually.
13119  **/
13120 void
13121 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
13122                                gboolean     reorderable)
13123 {
13124   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13125
13126   reorderable = reorderable != FALSE;
13127
13128   if (tree_view->priv->reorderable == reorderable)
13129     return;
13130
13131   if (reorderable)
13132     {
13133       const GtkTargetEntry row_targets[] = {
13134         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
13135       };
13136
13137       gtk_tree_view_enable_model_drag_source (tree_view,
13138                                               GDK_BUTTON1_MASK,
13139                                               row_targets,
13140                                               G_N_ELEMENTS (row_targets),
13141                                               GDK_ACTION_MOVE);
13142       gtk_tree_view_enable_model_drag_dest (tree_view,
13143                                             row_targets,
13144                                             G_N_ELEMENTS (row_targets),
13145                                             GDK_ACTION_MOVE);
13146     }
13147   else
13148     {
13149       gtk_tree_view_unset_rows_drag_source (tree_view);
13150       gtk_tree_view_unset_rows_drag_dest (tree_view);
13151     }
13152
13153   tree_view->priv->reorderable = reorderable;
13154
13155   g_object_notify (G_OBJECT (tree_view), "reorderable");
13156 }
13157
13158 static void
13159 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
13160                                GtkTreePath     *path,
13161                                SetCursorFlags   flags)
13162 {
13163   if (!(flags & CURSOR_INVALID) && tree_view->priv->cursor_node)
13164     {
13165       _gtk_tree_view_accessible_remove_state (tree_view,
13166                                               tree_view->priv->cursor_tree,
13167                                               tree_view->priv->cursor_node,
13168                                               GTK_CELL_RENDERER_FOCUSED);
13169       _gtk_tree_view_queue_draw_node (tree_view,
13170                                       tree_view->priv->cursor_tree,
13171                                       tree_view->priv->cursor_node,
13172                                       NULL);
13173     }
13174
13175   /* One cannot set the cursor on a separator.   Also, if
13176    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
13177    * before finding the tree and node belonging to path.  The
13178    * path maps to a non-existing path and we will silently bail out.
13179    * We unset tree and node to avoid further processing.
13180    */
13181   if (path == NULL ||
13182       row_is_separator (tree_view, NULL, path)
13183       || _gtk_tree_view_find_node (tree_view,
13184                                    path,
13185                                    &tree_view->priv->cursor_tree,
13186                                    &tree_view->priv->cursor_node))
13187     {
13188       tree_view->priv->cursor_tree = NULL;
13189       tree_view->priv->cursor_node = NULL;
13190     }
13191
13192   if (tree_view->priv->cursor_node != NULL)
13193     {
13194       GtkRBTree *new_tree = NULL;
13195       GtkRBNode *new_node = NULL;
13196
13197       if ((flags & CLEAR_AND_SELECT) && !tree_view->priv->modify_selection_pressed)
13198         {
13199           GtkTreeSelectMode mode = 0;
13200
13201           if (tree_view->priv->extend_selection_pressed)
13202             mode |= GTK_TREE_SELECT_MODE_EXTEND;
13203
13204           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
13205                                                     tree_view->priv->cursor_node,
13206                                                     tree_view->priv->cursor_tree,
13207                                                     path,
13208                                                     mode,
13209                                                     FALSE);
13210         }
13211
13212       /* We have to re-find tree and node here again, somebody might have
13213        * cleared the node or the whole tree in the GtkTreeSelection::changed
13214        * callback. If the nodes differ we bail out here.
13215        */
13216       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
13217
13218       if (tree_view->priv->cursor_node != new_node)
13219         return;
13220
13221       if (flags & CLAMP_NODE)
13222         {
13223           gtk_tree_view_clamp_node_visible (tree_view,
13224                                             tree_view->priv->cursor_tree,
13225                                             tree_view->priv->cursor_node);
13226           _gtk_tree_view_queue_draw_node (tree_view,
13227                                           tree_view->priv->cursor_tree,
13228                                           tree_view->priv->cursor_node,
13229                                           NULL);
13230         }
13231
13232       _gtk_tree_view_accessible_add_state (tree_view,
13233                                            tree_view->priv->cursor_tree,
13234                                            tree_view->priv->cursor_node,
13235                                            GTK_CELL_RENDERER_FOCUSED);
13236     }
13237
13238   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
13239 }
13240
13241 /**
13242  * gtk_tree_view_get_cursor:
13243  * @tree_view: A #GtkTreeView
13244  * @path: (out) (transfer full) (allow-none): A pointer to be filled with the current cursor path, or %NULL
13245  * @focus_column: (out) (transfer none) (allow-none): A pointer to be filled with the current focus column, or %NULL
13246  *
13247  * Fills in @path and @focus_column with the current path and focus column.  If
13248  * the cursor isn't currently set, then *@path will be %NULL.  If no column
13249  * currently has focus, then *@focus_column will be %NULL.
13250  *
13251  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
13252  * you are done with it.
13253  **/
13254 void
13255 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
13256                           GtkTreePath       **path,
13257                           GtkTreeViewColumn **focus_column)
13258 {
13259   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13260
13261   if (path)
13262     {
13263       if (tree_view->priv->cursor_node)
13264         *path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
13265                                                 tree_view->priv->cursor_node);
13266       else
13267         *path = NULL;
13268     }
13269
13270   if (focus_column)
13271     {
13272       *focus_column = tree_view->priv->focus_column;
13273     }
13274 }
13275
13276 /**
13277  * gtk_tree_view_set_cursor:
13278  * @tree_view: A #GtkTreeView
13279  * @path: A #GtkTreePath
13280  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13281  * @start_editing: %TRUE if the specified cell should start being edited.
13282  *
13283  * Sets the current keyboard focus to be at @path, and selects it.  This is
13284  * useful when you want to focus the user's attention on a particular row.  If
13285  * @focus_column is not %NULL, then focus is given to the column specified by
13286  * it. Additionally, if @focus_column is specified, and @start_editing is
13287  * %TRUE, then editing should be started in the specified cell.
13288  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
13289  * in order to give keyboard focus to the widget.  Please note that editing
13290  * can only happen when the widget is realized.
13291  *
13292  * If @path is invalid for @model, the current cursor (if any) will be unset
13293  * and the function will return without failing.
13294  **/
13295 void
13296 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
13297                           GtkTreePath       *path,
13298                           GtkTreeViewColumn *focus_column,
13299                           gboolean           start_editing)
13300 {
13301   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
13302                                     NULL, start_editing);
13303 }
13304
13305 /**
13306  * gtk_tree_view_set_cursor_on_cell:
13307  * @tree_view: A #GtkTreeView
13308  * @path: A #GtkTreePath
13309  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
13310  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
13311  * @start_editing: %TRUE if the specified cell should start being edited.
13312  *
13313  * Sets the current keyboard focus to be at @path, and selects it.  This is
13314  * useful when you want to focus the user's attention on a particular row.  If
13315  * @focus_column is not %NULL, then focus is given to the column specified by
13316  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
13317  * contains 2 or more editable or activatable cells, then focus is given to
13318  * the cell specified by @focus_cell. Additionally, if @focus_column is
13319  * specified, and @start_editing is %TRUE, then editing should be started in
13320  * the specified cell.  This function is often followed by
13321  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
13322  * widget.  Please note that editing can only happen when the widget is
13323  * realized.
13324  *
13325  * If @path is invalid for @model, the current cursor (if any) will be unset
13326  * and the function will return without failing.
13327  *
13328  * Since: 2.2
13329  **/
13330 void
13331 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
13332                                   GtkTreePath       *path,
13333                                   GtkTreeViewColumn *focus_column,
13334                                   GtkCellRenderer   *focus_cell,
13335                                   gboolean           start_editing)
13336 {
13337   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13338   g_return_if_fail (path != NULL);
13339   g_return_if_fail (focus_column == NULL || GTK_IS_TREE_VIEW_COLUMN (focus_column));
13340
13341   if (!tree_view->priv->model)
13342     return;
13343
13344   if (focus_cell)
13345     {
13346       g_return_if_fail (focus_column);
13347       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
13348     }
13349
13350   /* cancel the current editing, if it exists */
13351   if (tree_view->priv->edited_column &&
13352       gtk_cell_area_get_edit_widget
13353       (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (tree_view->priv->edited_column))))
13354     gtk_tree_view_stop_editing (tree_view, TRUE);
13355
13356   gtk_tree_view_real_set_cursor (tree_view, path, CLEAR_AND_SELECT | CLAMP_NODE);
13357
13358   if (focus_column &&
13359       gtk_tree_view_column_get_visible (focus_column))
13360     {
13361       GList *list;
13362       gboolean column_in_tree = FALSE;
13363
13364       for (list = tree_view->priv->columns; list; list = list->next)
13365         if (list->data == focus_column)
13366           {
13367             column_in_tree = TRUE;
13368             break;
13369           }
13370       g_return_if_fail (column_in_tree);
13371       _gtk_tree_view_set_focus_column (tree_view, focus_column);
13372       if (focus_cell)
13373         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
13374       if (start_editing)
13375         gtk_tree_view_start_editing (tree_view, path, TRUE);
13376     }
13377 }
13378
13379 /**
13380  * gtk_tree_view_get_bin_window:
13381  * @tree_view: A #GtkTreeView
13382  *
13383  * Returns the window that @tree_view renders to.
13384  * This is used primarily to compare to <literal>event->window</literal>
13385  * to confirm that the event on @tree_view is on the right window.
13386  *
13387  * Return value: (transfer none): A #GdkWindow, or %NULL when @tree_view
13388  *     hasn't been realized yet
13389  **/
13390 GdkWindow *
13391 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
13392 {
13393   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13394
13395   return tree_view->priv->bin_window;
13396 }
13397
13398 /**
13399  * gtk_tree_view_get_path_at_pos:
13400  * @tree_view: A #GtkTreeView.
13401  * @x: The x position to be identified (relative to bin_window).
13402  * @y: The y position to be identified (relative to bin_window).
13403  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
13404  * @column: (out) (transfer none) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
13405  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
13406  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
13407  *
13408  * Finds the path at the point (@x, @y), relative to bin_window coordinates
13409  * (please see gtk_tree_view_get_bin_window()).
13410  * That is, @x and @y are relative to an events coordinates. @x and @y must
13411  * come from an event on the @tree_view only where <literal>event->window ==
13412  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
13413  * things like popup menus. If @path is non-%NULL, then it will be filled
13414  * with the #GtkTreePath at that point.  This path should be freed with
13415  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
13416  * with the column at that point.  @cell_x and @cell_y return the coordinates
13417  * relative to the cell background (i.e. the @background_area passed to
13418  * gtk_cell_renderer_render()).  This function is only meaningful if
13419  * @tree_view is realized.  Therefore this function will always return %FALSE
13420  * if @tree_view is not realized or does not have a model.
13421  *
13422  * For converting widget coordinates (eg. the ones you get from
13423  * GtkWidget::query-tooltip), please see
13424  * gtk_tree_view_convert_widget_to_bin_window_coords().
13425  *
13426  * Return value: %TRUE if a row exists at that coordinate.
13427  **/
13428 gboolean
13429 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
13430                                gint                x,
13431                                gint                y,
13432                                GtkTreePath       **path,
13433                                GtkTreeViewColumn **column,
13434                                gint               *cell_x,
13435                                gint               *cell_y)
13436 {
13437   GtkRBTree *tree;
13438   GtkRBNode *node;
13439   gint y_offset;
13440
13441   g_return_val_if_fail (tree_view != NULL, FALSE);
13442
13443   if (path)
13444     *path = NULL;
13445   if (column)
13446     *column = NULL;
13447
13448   if (tree_view->priv->bin_window == NULL)
13449     return FALSE;
13450
13451   if (tree_view->priv->tree == NULL)
13452     return FALSE;
13453
13454   if (x > gtk_adjustment_get_upper (tree_view->priv->hadjustment))
13455     return FALSE;
13456
13457   if (x < 0 || y < 0)
13458     return FALSE;
13459
13460   if (column || cell_x)
13461     {
13462       GtkTreeViewColumn *tmp_column;
13463       GtkTreeViewColumn *last_column = NULL;
13464       GList *list;
13465       gint remaining_x = x;
13466       gboolean found = FALSE;
13467       gboolean rtl;
13468       gint width;
13469
13470       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
13471       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13472            list;
13473            list = (rtl ? list->prev : list->next))
13474         {
13475           tmp_column = list->data;
13476
13477           if (gtk_tree_view_column_get_visible (tmp_column) == FALSE)
13478             continue;
13479
13480           last_column = tmp_column;
13481           width = gtk_tree_view_column_get_width (tmp_column);
13482           if (remaining_x <= width)
13483             {
13484               found = TRUE;
13485
13486               if (column)
13487                 *column = tmp_column;
13488
13489               if (cell_x)
13490                 *cell_x = remaining_x;
13491
13492               break;
13493             }
13494           remaining_x -= width;
13495         }
13496
13497       /* If found is FALSE and there is a last_column, then it the remainder
13498        * space is in that area
13499        */
13500       if (!found)
13501         {
13502           if (last_column)
13503             {
13504               if (column)
13505                 *column = last_column;
13506
13507               if (cell_x)
13508                 *cell_x = gtk_tree_view_column_get_width (last_column) + remaining_x;
13509             }
13510           else
13511             {
13512               return FALSE;
13513             }
13514         }
13515     }
13516
13517   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
13518                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
13519                                       &tree, &node);
13520
13521   if (tree == NULL)
13522     return FALSE;
13523
13524   if (cell_y)
13525     *cell_y = y_offset;
13526
13527   if (path)
13528     *path = _gtk_tree_path_new_from_rbtree (tree, node);
13529
13530   return TRUE;
13531 }
13532
13533
13534 static inline gint
13535 gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
13536                                     GtkRBNode   *node,
13537                                     gint         vertical_separator)
13538 {
13539   int expander_size = gtk_tree_view_get_expander_size (tree_view);
13540   int height;
13541
13542   /* The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
13543    * i.e. just the cells, no spacing.
13544    *
13545    * The cell area height is at least expander_size - vertical_separator.
13546    * For regular nodes, the height is then at least expander_size. We should
13547    * be able to enforce the expander_size minimum here, because this
13548    * function will not be called for irregular (e.g. separator) rows.
13549    */
13550   height = gtk_tree_view_get_row_height (tree_view, node);
13551   if (height < expander_size)
13552     height = expander_size;
13553
13554   return height - vertical_separator;
13555 }
13556
13557 static inline gint
13558 gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
13559                                       GtkRBTree   *tree,
13560                                       GtkRBNode   *node,
13561                                       gint         vertical_separator)
13562 {
13563   int offset;
13564
13565   offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13566   offset += vertical_separator / 2;
13567
13568   return offset;
13569 }
13570
13571 /**
13572  * gtk_tree_view_get_cell_area:
13573  * @tree_view: a #GtkTreeView
13574  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13575  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
13576  * @rect: (out): rectangle to fill with cell rect
13577  *
13578  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13579  * row specified by @path and the column specified by @column.  If @path is
13580  * %NULL, or points to a path not currently displayed, the @y and @height fields
13581  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13582  * fields will be filled with 0.  The sum of all cell rects does not cover the
13583  * entire tree; there are extra pixels in between rows, for example. The
13584  * returned rectangle is equivalent to the @cell_area passed to
13585  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
13586  * realized.
13587  **/
13588 void
13589 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
13590                              GtkTreePath        *path,
13591                              GtkTreeViewColumn  *column,
13592                              GdkRectangle       *rect)
13593 {
13594   GtkRBTree *tree = NULL;
13595   GtkRBNode *node = NULL;
13596   gint vertical_separator;
13597   gint horizontal_separator;
13598
13599   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13600   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13601   g_return_if_fail (rect != NULL);
13602   g_return_if_fail (!column || gtk_tree_view_column_get_tree_view (column) == (GtkWidget *) tree_view);
13603   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
13604
13605   gtk_widget_style_get (GTK_WIDGET (tree_view),
13606                         "vertical-separator", &vertical_separator,
13607                         "horizontal-separator", &horizontal_separator,
13608                         NULL);
13609
13610   rect->x = 0;
13611   rect->y = 0;
13612   rect->width = 0;
13613   rect->height = 0;
13614
13615   if (column)
13616     {
13617       rect->x = gtk_tree_view_column_get_x_offset (column) + horizontal_separator/2;
13618       rect->width = gtk_tree_view_column_get_width (column) - horizontal_separator;
13619     }
13620
13621   if (path)
13622     {
13623       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
13624
13625       /* Get vertical coords */
13626       if ((!ret && tree == NULL) || ret)
13627         return;
13628
13629       if (row_is_separator (tree_view, NULL, path))
13630         {
13631           /* There isn't really a "cell area" for separator, so we
13632            * return the y, height values for background area instead.
13633            */
13634           rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13635           rect->height = gtk_tree_view_get_row_height (tree_view, node);
13636         }
13637       else
13638         {
13639           rect->y = gtk_tree_view_get_cell_area_y_offset (tree_view, tree, node,
13640                                                           vertical_separator);
13641           rect->height = gtk_tree_view_get_cell_area_height (tree_view, node,
13642                                                              vertical_separator);
13643         }
13644
13645       if (column &&
13646           gtk_tree_view_is_expander_column (tree_view, column))
13647         {
13648           gint depth = gtk_tree_path_get_depth (path);
13649           gboolean rtl;
13650
13651           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13652
13653           if (!rtl)
13654             rect->x += (depth - 1) * tree_view->priv->level_indentation;
13655           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
13656
13657           if (gtk_tree_view_draw_expanders (tree_view))
13658             {
13659               int expander_size = gtk_tree_view_get_expander_size (tree_view);
13660               if (!rtl)
13661                 rect->x += depth * expander_size;
13662               rect->width -= depth * expander_size;
13663             }
13664
13665           rect->width = MAX (rect->width, 0);
13666         }
13667     }
13668 }
13669
13670 static inline gint
13671 gtk_tree_view_get_row_height (GtkTreeView *tree_view,
13672                               GtkRBNode   *node)
13673 {
13674   int expander_size = gtk_tree_view_get_expander_size (tree_view);
13675   int height;
13676
13677   /* The "background" areas of all rows/cells add up to cover the entire tree.
13678    * The background includes all inter-row and inter-cell spacing.
13679    *
13680    * If the row pointed at by node does not have a height set, we default
13681    * to expander_size, which is the minimum height for regular nodes.
13682    * Non-regular nodes (e.g. separators) can have a height set smaller
13683    * than expander_size and should not be overruled here.
13684    */
13685   height = GTK_RBNODE_GET_HEIGHT (node);
13686   if (height <= 0)
13687     height = expander_size;
13688
13689   return height;
13690 }
13691
13692 static inline gint
13693 gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
13694                                 GtkRBTree   *tree,
13695                                 GtkRBNode   *node)
13696 {
13697   int offset;
13698
13699   offset = _gtk_rbtree_node_find_offset (tree, node);
13700
13701   return RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, offset);
13702 }
13703
13704 /**
13705  * gtk_tree_view_get_background_area:
13706  * @tree_view: a #GtkTreeView
13707  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13708  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
13709  * @rect: (out): rectangle to fill with cell background rect
13710  *
13711  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13712  * row specified by @path and the column specified by @column.  If @path is
13713  * %NULL, or points to a node not found in the tree, the @y and @height fields of
13714  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13715  * fields will be filled with 0.  The returned rectangle is equivalent to the
13716  * @background_area passed to gtk_cell_renderer_render().  These background
13717  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
13718  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
13719  * itself, excluding surrounding borders and the tree expander area.
13720  *
13721  **/
13722 void
13723 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
13724                                    GtkTreePath        *path,
13725                                    GtkTreeViewColumn  *column,
13726                                    GdkRectangle       *rect)
13727 {
13728   GtkRBTree *tree = NULL;
13729   GtkRBNode *node = NULL;
13730
13731   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13732   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13733   g_return_if_fail (rect != NULL);
13734
13735   rect->x = 0;
13736   rect->y = 0;
13737   rect->width = 0;
13738   rect->height = 0;
13739
13740   if (path)
13741     {
13742       /* Get vertical coords */
13743
13744       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
13745           tree == NULL)
13746         return;
13747
13748       rect->y = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
13749       rect->height = gtk_tree_view_get_row_height (tree_view, node);
13750     }
13751
13752   if (column)
13753     {
13754       gint x2 = 0;
13755
13756       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
13757       rect->width = x2 - rect->x;
13758     }
13759 }
13760
13761 /**
13762  * gtk_tree_view_get_visible_rect:
13763  * @tree_view: a #GtkTreeView
13764  * @visible_rect: (out): rectangle to fill
13765  *
13766  * Fills @visible_rect with the currently-visible region of the
13767  * buffer, in tree coordinates. Convert to bin_window coordinates with
13768  * gtk_tree_view_convert_tree_to_bin_window_coords().
13769  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
13770  * scrollable area of the tree.
13771  **/
13772 void
13773 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
13774                                 GdkRectangle *visible_rect)
13775 {
13776   GtkAllocation allocation;
13777   GtkWidget *widget;
13778
13779   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13780
13781   widget = GTK_WIDGET (tree_view);
13782
13783   if (visible_rect)
13784     {
13785       gtk_widget_get_allocation (widget, &allocation);
13786       visible_rect->x = gtk_adjustment_get_value (tree_view->priv->hadjustment);
13787       visible_rect->y = gtk_adjustment_get_value (tree_view->priv->vadjustment);
13788       visible_rect->width = allocation.width;
13789       visible_rect->height = allocation.height - gtk_tree_view_get_effective_header_height (tree_view);
13790     }
13791 }
13792
13793 /**
13794  * gtk_tree_view_convert_widget_to_tree_coords:
13795  * @tree_view: a #GtkTreeView
13796  * @wx: X coordinate relative to the widget
13797  * @wy: Y coordinate relative to the widget
13798  * @tx: (out): return location for tree X coordinate
13799  * @ty: (out): return location for tree Y coordinate
13800  *
13801  * Converts widget coordinates to coordinates for the
13802  * tree (the full scrollable area of the tree).
13803  *
13804  * Since: 2.12
13805  **/
13806 void
13807 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13808                                              gint         wx,
13809                                              gint         wy,
13810                                              gint        *tx,
13811                                              gint        *ty)
13812 {
13813   gint x, y;
13814
13815   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13816
13817   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13818                                                      wx, wy,
13819                                                      &x, &y);
13820   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13821                                                    x, y,
13822                                                    tx, ty);
13823 }
13824
13825 /**
13826  * gtk_tree_view_convert_tree_to_widget_coords:
13827  * @tree_view: a #GtkTreeView
13828  * @tx: X coordinate relative to the tree
13829  * @ty: Y coordinate relative to the tree
13830  * @wx: (out): return location for widget X coordinate
13831  * @wy: (out): return location for widget Y coordinate
13832  *
13833  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13834  * to widget coordinates.
13835  *
13836  * Since: 2.12
13837  **/
13838 void
13839 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13840                                              gint         tx,
13841                                              gint         ty,
13842                                              gint        *wx,
13843                                              gint        *wy)
13844 {
13845   gint x, y;
13846
13847   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13848
13849   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13850                                                    tx, ty,
13851                                                    &x, &y);
13852   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13853                                                      x, y,
13854                                                      wx, wy);
13855 }
13856
13857 /**
13858  * gtk_tree_view_convert_widget_to_bin_window_coords:
13859  * @tree_view: a #GtkTreeView
13860  * @wx: X coordinate relative to the widget
13861  * @wy: Y coordinate relative to the widget
13862  * @bx: (out): return location for bin_window X coordinate
13863  * @by: (out): return location for bin_window Y coordinate
13864  *
13865  * Converts widget coordinates to coordinates for the bin_window
13866  * (see gtk_tree_view_get_bin_window()).
13867  *
13868  * Since: 2.12
13869  **/
13870 void
13871 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13872                                                    gint         wx,
13873                                                    gint         wy,
13874                                                    gint        *bx,
13875                                                    gint        *by)
13876 {
13877   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13878
13879   if (bx)
13880     *bx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
13881   if (by)
13882     *by = wy - gtk_tree_view_get_effective_header_height (tree_view);
13883 }
13884
13885 /**
13886  * gtk_tree_view_convert_bin_window_to_widget_coords:
13887  * @tree_view: a #GtkTreeView
13888  * @bx: bin_window X coordinate
13889  * @by: bin_window Y coordinate
13890  * @wx: (out): return location for widget X coordinate
13891  * @wy: (out): return location for widget Y coordinate
13892  *
13893  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13894  * to widget relative coordinates.
13895  *
13896  * Since: 2.12
13897  **/
13898 void
13899 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13900                                                    gint         bx,
13901                                                    gint         by,
13902                                                    gint        *wx,
13903                                                    gint        *wy)
13904 {
13905   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13906
13907   if (wx)
13908     *wx = bx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
13909   if (wy)
13910     *wy = by + gtk_tree_view_get_effective_header_height (tree_view);
13911 }
13912
13913 /**
13914  * gtk_tree_view_convert_tree_to_bin_window_coords:
13915  * @tree_view: a #GtkTreeView
13916  * @tx: tree X coordinate
13917  * @ty: tree Y coordinate
13918  * @bx: (out): return location for X coordinate relative to bin_window
13919  * @by: (out): return location for Y coordinate relative to bin_window
13920  *
13921  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13922  * to bin_window coordinates.
13923  *
13924  * Since: 2.12
13925  **/
13926 void
13927 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13928                                                  gint         tx,
13929                                                  gint         ty,
13930                                                  gint        *bx,
13931                                                  gint        *by)
13932 {
13933   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13934
13935   if (bx)
13936     *bx = tx;
13937   if (by)
13938     *by = ty - tree_view->priv->dy;
13939 }
13940
13941 /**
13942  * gtk_tree_view_convert_bin_window_to_tree_coords:
13943  * @tree_view: a #GtkTreeView
13944  * @bx: X coordinate relative to bin_window
13945  * @by: Y coordinate relative to bin_window
13946  * @tx: (out): return location for tree X coordinate
13947  * @ty: (out): return location for tree Y coordinate
13948  *
13949  * Converts bin_window coordinates to coordinates for the
13950  * tree (the full scrollable area of the tree).
13951  *
13952  * Since: 2.12
13953  **/
13954 void
13955 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
13956                                                  gint         bx,
13957                                                  gint         by,
13958                                                  gint        *tx,
13959                                                  gint        *ty)
13960 {
13961   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13962
13963   if (tx)
13964     *tx = bx;
13965   if (ty)
13966     *ty = by + tree_view->priv->dy;
13967 }
13968
13969
13970
13971 /**
13972  * gtk_tree_view_get_visible_range:
13973  * @tree_view: A #GtkTreeView
13974  * @start_path: (out) (allow-none): Return location for start of region,
13975  *              or %NULL.
13976  * @end_path: (out) (allow-none): Return location for end of region, or %NULL.
13977  *
13978  * Sets @start_path and @end_path to be the first and last visible path.
13979  * Note that there may be invisible paths in between.
13980  *
13981  * The paths should be freed with gtk_tree_path_free() after use.
13982  *
13983  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
13984  *
13985  * Since: 2.8
13986  **/
13987 gboolean
13988 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
13989                                  GtkTreePath **start_path,
13990                                  GtkTreePath **end_path)
13991 {
13992   GtkRBTree *tree;
13993   GtkRBNode *node;
13994   gboolean retval;
13995
13996   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13997
13998   if (!tree_view->priv->tree)
13999     return FALSE;
14000
14001   retval = TRUE;
14002
14003   if (start_path)
14004     {
14005       _gtk_rbtree_find_offset (tree_view->priv->tree,
14006                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
14007                                &tree, &node);
14008       if (node)
14009         *start_path = _gtk_tree_path_new_from_rbtree (tree, node);
14010       else
14011         retval = FALSE;
14012     }
14013
14014   if (end_path)
14015     {
14016       gint y;
14017
14018       if (tree_view->priv->height < gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
14019         y = tree_view->priv->height - 1;
14020       else
14021         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1;
14022
14023       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
14024       if (node)
14025         *end_path = _gtk_tree_path_new_from_rbtree (tree, node);
14026       else
14027         retval = FALSE;
14028     }
14029
14030   return retval;
14031 }
14032
14033 /**
14034  * gtk_tree_view_is_blank_at_pos:
14035  * @tree_view: A #GtkTreeView
14036  * @x: The x position to be identified (relative to bin_window)
14037  * @y: The y position to be identified (relative to bin_window)
14038  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
14039  * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
14040  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
14041  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
14042  *
14043  * Determine whether the point (@x, @y) in @tree_view is blank, that is no
14044  * cell content nor an expander arrow is drawn at the location. If so, the
14045  * location can be considered as the background. You might wish to take
14046  * special action on clicks on the background, such as clearing a current
14047  * selection, having a custom context menu or starting rubber banding.
14048  *
14049  * The @x and @y coordinate that are provided must be relative to bin_window
14050  * coordinates.  That is, @x and @y must come from an event on @tree_view
14051  * where <literal>event->window == gtk_tree_view_get_bin_window (<!-- -->)</literal>.
14052  *
14053  * For converting widget coordinates (eg. the ones you get from
14054  * GtkWidget::query-tooltip), please see
14055  * gtk_tree_view_convert_widget_to_bin_window_coords().
14056  *
14057  * The @path, @column, @cell_x and @cell_y arguments will be filled in
14058  * likewise as for gtk_tree_view_get_path_at_pos().  Please see
14059  * gtk_tree_view_get_path_at_pos() for more information.
14060  *
14061  * Return value: %TRUE if the area at the given coordinates is blank,
14062  * %FALSE otherwise.
14063  *
14064  * Since: 3.0
14065  */
14066 gboolean
14067 gtk_tree_view_is_blank_at_pos (GtkTreeView       *tree_view,
14068                                gint                x,
14069                                gint                y,
14070                                GtkTreePath       **path,
14071                                GtkTreeViewColumn **column,
14072                                gint               *cell_x,
14073                                gint               *cell_y)
14074 {
14075   GtkRBTree *tree;
14076   GtkRBNode *node;
14077   GtkTreeIter iter;
14078   GtkTreePath *real_path;
14079   GtkTreeViewColumn *real_column;
14080   GdkRectangle cell_area, background_area;
14081
14082   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14083
14084   if (!gtk_tree_view_get_path_at_pos (tree_view, x, y,
14085                                       &real_path, &real_column,
14086                                       cell_x, cell_y))
14087     /* If there's no path here, it is blank */
14088     return TRUE;
14089
14090   if (path)
14091     *path = real_path;
14092
14093   if (column)
14094     *column = real_column;
14095
14096   gtk_tree_model_get_iter (tree_view->priv->model, &iter, real_path);
14097   _gtk_tree_view_find_node (tree_view, real_path, &tree, &node);
14098
14099   /* Check if there's an expander arrow at (x, y) */
14100   if (real_column == tree_view->priv->expander_column
14101       && gtk_tree_view_draw_expanders (tree_view))
14102     {
14103       gboolean over_arrow;
14104
14105       over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
14106
14107       if (over_arrow)
14108         {
14109           if (!path)
14110             gtk_tree_path_free (real_path);
14111           return FALSE;
14112         }
14113     }
14114
14115   /* Otherwise, have the column see if there's a cell at (x, y) */
14116   gtk_tree_view_column_cell_set_cell_data (real_column,
14117                                            tree_view->priv->model,
14118                                            &iter,
14119                                            GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14120                                            node->children ? TRUE : FALSE);
14121
14122   gtk_tree_view_get_background_area (tree_view, real_path, real_column,
14123                                      &background_area);
14124   gtk_tree_view_get_cell_area (tree_view, real_path, real_column,
14125                                &cell_area);
14126
14127   if (!path)
14128     gtk_tree_path_free (real_path);
14129
14130   return _gtk_tree_view_column_is_blank_at_pos (real_column,
14131                                                 &cell_area,
14132                                                 &background_area,
14133                                                 x, y);
14134 }
14135
14136 static void
14137 unset_reorderable (GtkTreeView *tree_view)
14138 {
14139   if (tree_view->priv->reorderable)
14140     {
14141       tree_view->priv->reorderable = FALSE;
14142       g_object_notify (G_OBJECT (tree_view), "reorderable");
14143     }
14144 }
14145
14146 /**
14147  * gtk_tree_view_enable_model_drag_source:
14148  * @tree_view: a #GtkTreeView
14149  * @start_button_mask: Mask of allowed buttons to start drag
14150  * @targets: (array length=n_targets): the table of targets that the drag will support
14151  * @n_targets: the number of items in @targets
14152  * @actions: the bitmask of possible actions for a drag from this
14153  *    widget
14154  *
14155  * Turns @tree_view into a drag source for automatic DND. Calling this
14156  * method sets #GtkTreeView:reorderable to %FALSE.
14157  **/
14158 void
14159 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
14160                                         GdkModifierType           start_button_mask,
14161                                         const GtkTargetEntry     *targets,
14162                                         gint                      n_targets,
14163                                         GdkDragAction             actions)
14164 {
14165   TreeViewDragInfo *di;
14166
14167   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14168
14169   gtk_drag_source_set (GTK_WIDGET (tree_view),
14170                        0,
14171                        targets,
14172                        n_targets,
14173                        actions);
14174
14175   di = ensure_info (tree_view);
14176
14177   di->start_button_mask = start_button_mask;
14178   di->source_actions = actions;
14179   di->source_set = TRUE;
14180
14181   unset_reorderable (tree_view);
14182 }
14183
14184 /**
14185  * gtk_tree_view_enable_model_drag_dest:
14186  * @tree_view: a #GtkTreeView
14187  * @targets: (array length=n_targets): the table of targets that
14188  *           the drag will support
14189  * @n_targets: the number of items in @targets
14190  * @actions: the bitmask of possible actions for a drag from this
14191  *    widget
14192  *
14193  * Turns @tree_view into a drop destination for automatic DND. Calling
14194  * this method sets #GtkTreeView:reorderable to %FALSE.
14195  **/
14196 void
14197 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
14198                                       const GtkTargetEntry     *targets,
14199                                       gint                      n_targets,
14200                                       GdkDragAction             actions)
14201 {
14202   TreeViewDragInfo *di;
14203
14204   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14205
14206   gtk_drag_dest_set (GTK_WIDGET (tree_view),
14207                      0,
14208                      targets,
14209                      n_targets,
14210                      actions);
14211
14212   di = ensure_info (tree_view);
14213   di->dest_set = TRUE;
14214
14215   unset_reorderable (tree_view);
14216 }
14217
14218 /**
14219  * gtk_tree_view_unset_rows_drag_source:
14220  * @tree_view: a #GtkTreeView
14221  *
14222  * Undoes the effect of
14223  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
14224  * #GtkTreeView:reorderable to %FALSE.
14225  **/
14226 void
14227 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
14228 {
14229   TreeViewDragInfo *di;
14230
14231   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14232
14233   di = get_info (tree_view);
14234
14235   if (di)
14236     {
14237       if (di->source_set)
14238         {
14239           gtk_drag_source_unset (GTK_WIDGET (tree_view));
14240           di->source_set = FALSE;
14241         }
14242
14243       if (!di->dest_set && !di->source_set)
14244         remove_info (tree_view);
14245     }
14246
14247   unset_reorderable (tree_view);
14248 }
14249
14250 /**
14251  * gtk_tree_view_unset_rows_drag_dest:
14252  * @tree_view: a #GtkTreeView
14253  *
14254  * Undoes the effect of
14255  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
14256  * #GtkTreeView:reorderable to %FALSE.
14257  **/
14258 void
14259 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
14260 {
14261   TreeViewDragInfo *di;
14262
14263   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14264
14265   di = get_info (tree_view);
14266
14267   if (di)
14268     {
14269       if (di->dest_set)
14270         {
14271           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
14272           di->dest_set = FALSE;
14273         }
14274
14275       if (!di->dest_set && !di->source_set)
14276         remove_info (tree_view);
14277     }
14278
14279   unset_reorderable (tree_view);
14280 }
14281
14282 /**
14283  * gtk_tree_view_set_drag_dest_row:
14284  * @tree_view: a #GtkTreeView
14285  * @path: (allow-none): The path of the row to highlight, or %NULL
14286  * @pos: Specifies whether to drop before, after or into the row
14287  *
14288  * Sets the row that is highlighted for feedback.
14289  * If @path is %NULL, an existing highlight is removed.
14290  */
14291 void
14292 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
14293                                  GtkTreePath            *path,
14294                                  GtkTreeViewDropPosition pos)
14295 {
14296   GtkTreePath *current_dest;
14297
14298   /* Note; this function is exported to allow a custom DND
14299    * implementation, so it can't touch TreeViewDragInfo
14300    */
14301
14302   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14303
14304   current_dest = NULL;
14305
14306   if (tree_view->priv->drag_dest_row)
14307     {
14308       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14309       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
14310     }
14311
14312   /* special case a drop on an empty model */
14313   tree_view->priv->empty_view_drop = 0;
14314
14315   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
14316       && gtk_tree_path_get_depth (path) == 1
14317       && gtk_tree_path_get_indices (path)[0] == 0)
14318     {
14319       gint n_children;
14320
14321       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
14322                                                    NULL);
14323
14324       if (!n_children)
14325         tree_view->priv->empty_view_drop = 1;
14326     }
14327
14328   tree_view->priv->drag_dest_pos = pos;
14329
14330   if (path)
14331     {
14332       tree_view->priv->drag_dest_row =
14333         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
14334       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
14335     }
14336   else
14337     tree_view->priv->drag_dest_row = NULL;
14338
14339   if (current_dest)
14340     {
14341       GtkRBTree *tree, *new_tree;
14342       GtkRBNode *node, *new_node;
14343
14344       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
14345       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
14346
14347       if (tree && node)
14348         {
14349           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
14350           if (new_tree && new_node)
14351             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
14352
14353           _gtk_rbtree_prev_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_tree_path_free (current_dest);
14358     }
14359 }
14360
14361 /**
14362  * gtk_tree_view_get_drag_dest_row:
14363  * @tree_view: a #GtkTreeView
14364  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14365  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14366  *
14367  * Gets information about the row that is highlighted for feedback.
14368  **/
14369 void
14370 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
14371                                  GtkTreePath             **path,
14372                                  GtkTreeViewDropPosition  *pos)
14373 {
14374   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14375
14376   if (path)
14377     {
14378       if (tree_view->priv->drag_dest_row)
14379         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
14380       else
14381         {
14382           if (tree_view->priv->empty_view_drop)
14383             *path = gtk_tree_path_new_from_indices (0, -1);
14384           else
14385             *path = NULL;
14386         }
14387     }
14388
14389   if (pos)
14390     *pos = tree_view->priv->drag_dest_pos;
14391 }
14392
14393 /**
14394  * gtk_tree_view_get_dest_row_at_pos:
14395  * @tree_view: a #GtkTreeView
14396  * @drag_x: the position to determine the destination row for
14397  * @drag_y: the position to determine the destination row for
14398  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
14399  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
14400  *
14401  * Determines the destination row for a given position.  @drag_x and
14402  * @drag_y are expected to be in widget coordinates.  This function is only
14403  * meaningful if @tree_view is realized.  Therefore this function will always
14404  * return %FALSE if @tree_view is not realized or does not have a model.
14405  *
14406  * Return value: whether there is a row at the given position, %TRUE if this
14407  * is indeed the case.
14408  **/
14409 gboolean
14410 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
14411                                    gint                     drag_x,
14412                                    gint                     drag_y,
14413                                    GtkTreePath            **path,
14414                                    GtkTreeViewDropPosition *pos)
14415 {
14416   gint cell_y;
14417   gint bin_x, bin_y;
14418   gdouble offset_into_row;
14419   gdouble third;
14420   GdkRectangle cell;
14421   GtkTreeViewColumn *column = NULL;
14422   GtkTreePath *tmp_path = NULL;
14423
14424   /* Note; this function is exported to allow a custom DND
14425    * implementation, so it can't touch TreeViewDragInfo
14426    */
14427
14428   g_return_val_if_fail (tree_view != NULL, FALSE);
14429   g_return_val_if_fail (drag_x >= 0, FALSE);
14430   g_return_val_if_fail (drag_y >= 0, FALSE);
14431
14432   if (path)
14433     *path = NULL;
14434
14435   if (tree_view->priv->bin_window == NULL)
14436     return FALSE;
14437
14438   if (tree_view->priv->tree == NULL)
14439     return FALSE;
14440
14441   /* If in the top third of a row, we drop before that row; if
14442    * in the bottom third, drop after that row; if in the middle,
14443    * and the row has children, drop into the row.
14444    */
14445   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
14446                                                      &bin_x, &bin_y);
14447
14448   if (!gtk_tree_view_get_path_at_pos (tree_view,
14449                                       bin_x,
14450                                       bin_y,
14451                                       &tmp_path,
14452                                       &column,
14453                                       NULL,
14454                                       &cell_y))
14455     return FALSE;
14456
14457   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
14458                                      &cell);
14459
14460   offset_into_row = cell_y;
14461
14462   if (path)
14463     *path = tmp_path;
14464   else
14465     gtk_tree_path_free (tmp_path);
14466
14467   tmp_path = NULL;
14468
14469   third = cell.height / 3.0;
14470
14471   if (pos)
14472     {
14473       if (offset_into_row < third)
14474         {
14475           *pos = GTK_TREE_VIEW_DROP_BEFORE;
14476         }
14477       else if (offset_into_row < (cell.height / 2.0))
14478         {
14479           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
14480         }
14481       else if (offset_into_row < third * 2.0)
14482         {
14483           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
14484         }
14485       else
14486         {
14487           *pos = GTK_TREE_VIEW_DROP_AFTER;
14488         }
14489     }
14490
14491   return TRUE;
14492 }
14493
14494
14495
14496 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
14497 /**
14498  * gtk_tree_view_create_row_drag_icon:
14499  * @tree_view: a #GtkTreeView
14500  * @path: a #GtkTreePath in @tree_view
14501  *
14502  * Creates a #cairo_surface_t representation of the row at @path.
14503  * This image is used for a drag icon.
14504  *
14505  * Return value: (transfer full): a newly-allocated surface of the drag icon.
14506  **/
14507 cairo_surface_t *
14508 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
14509                                     GtkTreePath  *path)
14510 {
14511   GtkTreeIter   iter;
14512   GtkRBTree    *tree;
14513   GtkRBNode    *node;
14514   GtkStyleContext *context;
14515   gint cell_offset;
14516   GList *list;
14517   GdkRectangle background_area;
14518   GtkWidget *widget;
14519   gint depth;
14520   /* start drawing inside the black outline */
14521   gint x = 1, y = 1;
14522   cairo_surface_t *surface;
14523   gint bin_window_width;
14524   gboolean is_separator = FALSE;
14525   gboolean rtl, allow_rules;
14526   cairo_t *cr;
14527
14528   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14529   g_return_val_if_fail (path != NULL, NULL);
14530
14531   widget = GTK_WIDGET (tree_view);
14532
14533   if (!gtk_widget_get_realized (widget))
14534     return NULL;
14535
14536   depth = gtk_tree_path_get_depth (path);
14537
14538   _gtk_tree_view_find_node (tree_view,
14539                             path,
14540                             &tree,
14541                             &node);
14542
14543   if (tree == NULL)
14544     return NULL;
14545
14546   if (!gtk_tree_model_get_iter (tree_view->priv->model,
14547                                 &iter,
14548                                 path))
14549     return NULL;
14550
14551   context = gtk_widget_get_style_context (widget);
14552
14553   gtk_style_context_save (context);
14554   gtk_style_context_add_region (context, GTK_STYLE_REGION_COLUMN, 0);
14555
14556   gtk_widget_style_get (widget,
14557                         "allow-rules", &allow_rules,
14558                         NULL);
14559
14560   if (allow_rules && tree_view->priv->has_rules)
14561     {
14562       GtkRegionFlags row_flags;
14563
14564       if ((_gtk_rbtree_node_get_index (tree, node) % 2))
14565         row_flags = GTK_REGION_ODD;
14566       else
14567         row_flags = GTK_REGION_EVEN;
14568
14569       gtk_style_context_add_region (context, GTK_STYLE_REGION_ROW, row_flags);
14570     }
14571
14572   is_separator = row_is_separator (tree_view, &iter, NULL);
14573
14574   cell_offset = x;
14575
14576   background_area.y = y;
14577   background_area.height = gtk_tree_view_get_row_height (tree_view, node);
14578
14579   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
14580
14581   surface = gdk_window_create_similar_surface (tree_view->priv->bin_window,
14582                                                CAIRO_CONTENT_COLOR,
14583                                                bin_window_width + 2,
14584                                                background_area.height + 2);
14585
14586   cr = cairo_create (surface);
14587
14588   gtk_render_background (context, cr, 0, 0,
14589                          bin_window_width + 2,
14590                          background_area.height + 2);
14591
14592   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
14593
14594   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
14595       list;
14596       list = (rtl ? list->prev : list->next))
14597     {
14598       GtkTreeViewColumn *column = list->data;
14599       GdkRectangle cell_area;
14600       gint vertical_separator;
14601
14602       if (!gtk_tree_view_column_get_visible (column))
14603         continue;
14604
14605       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
14606                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
14607                                                node->children?TRUE:FALSE);
14608
14609       background_area.x = cell_offset;
14610       background_area.width = gtk_tree_view_column_get_width (column);
14611
14612       gtk_widget_style_get (widget,
14613                             "vertical-separator", &vertical_separator,
14614                             NULL);
14615
14616       cell_area = background_area;
14617
14618       cell_area.y += vertical_separator / 2;
14619       cell_area.height -= vertical_separator;
14620
14621       if (gtk_tree_view_is_expander_column (tree_view, column))
14622         {
14623           if (!rtl)
14624             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
14625           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
14626
14627           if (gtk_tree_view_draw_expanders (tree_view))
14628             {
14629               int expander_size = gtk_tree_view_get_expander_size (tree_view);
14630               if (!rtl)
14631                 cell_area.x += depth * expander_size;
14632               cell_area.width -= depth * expander_size;
14633             }
14634         }
14635
14636       if (gtk_tree_view_column_cell_is_visible (column))
14637         {
14638           if (is_separator)
14639             {
14640               gtk_style_context_save (context);
14641               gtk_style_context_add_class (context, GTK_STYLE_CLASS_SEPARATOR);
14642
14643               gtk_render_line (context, cr,
14644                                cell_area.x,
14645                                cell_area.y + cell_area.height / 2,
14646                                cell_area.x + cell_area.width,
14647                                cell_area.y + cell_area.height / 2);
14648
14649               gtk_style_context_restore (context);
14650             }
14651           else
14652             {
14653               _gtk_tree_view_column_cell_render (column,
14654                                                  cr,
14655                                                  &background_area,
14656                                                  &cell_area,
14657                                                  0, FALSE);
14658             }
14659         }
14660       cell_offset += gtk_tree_view_column_get_width (column);
14661     }
14662
14663   cairo_set_source_rgb (cr, 0, 0, 0);
14664   cairo_rectangle (cr,
14665                    0.5, 0.5,
14666                    bin_window_width + 1,
14667                    background_area.height + 1);
14668   cairo_set_line_width (cr, 1.0);
14669   cairo_stroke (cr);
14670
14671   cairo_destroy (cr);
14672
14673   cairo_surface_set_device_offset (surface, 2, 2);
14674
14675   gtk_style_context_restore (context);
14676
14677   return surface;
14678 }
14679
14680
14681 /**
14682  * gtk_tree_view_set_destroy_count_func:
14683  * @tree_view: A #GtkTreeView
14684  * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
14685  * @data: (allow-none): User data to be passed to @func, or %NULL
14686  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14687  *
14688  * This function should almost never be used.  It is meant for private use by
14689  * ATK for determining the number of visible children that are removed when the
14690  * user collapses a row, or a row is deleted.
14691  *
14692  * Deprecated: 3.4: Accessibility does not need the function anymore.
14693  **/
14694 void
14695 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
14696                                       GtkTreeDestroyCountFunc  func,
14697                                       gpointer                 data,
14698                                       GDestroyNotify           destroy)
14699 {
14700   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14701
14702   if (tree_view->priv->destroy_count_destroy)
14703     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
14704
14705   tree_view->priv->destroy_count_func = func;
14706   tree_view->priv->destroy_count_data = data;
14707   tree_view->priv->destroy_count_destroy = destroy;
14708 }
14709
14710
14711 /*
14712  * Interactive search
14713  */
14714
14715 /**
14716  * gtk_tree_view_set_enable_search:
14717  * @tree_view: A #GtkTreeView
14718  * @enable_search: %TRUE, if the user can search interactively
14719  *
14720  * If @enable_search is set, then the user can type in text to search through
14721  * the tree interactively (this is sometimes called "typeahead find").
14722  *
14723  * Note that even if this is %FALSE, the user can still initiate a search
14724  * using the "start-interactive-search" key binding.
14725  */
14726 void
14727 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
14728                                  gboolean     enable_search)
14729 {
14730   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14731
14732   enable_search = !!enable_search;
14733
14734   if (tree_view->priv->enable_search != enable_search)
14735     {
14736        tree_view->priv->enable_search = enable_search;
14737        g_object_notify (G_OBJECT (tree_view), "enable-search");
14738     }
14739 }
14740
14741 /**
14742  * gtk_tree_view_get_enable_search:
14743  * @tree_view: A #GtkTreeView
14744  *
14745  * Returns whether or not the tree allows to start interactive searching
14746  * by typing in text.
14747  *
14748  * Return value: whether or not to let the user search interactively
14749  */
14750 gboolean
14751 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
14752 {
14753   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14754
14755   return tree_view->priv->enable_search;
14756 }
14757
14758
14759 /**
14760  * gtk_tree_view_get_search_column:
14761  * @tree_view: A #GtkTreeView
14762  *
14763  * Gets the column searched on by the interactive search code.
14764  *
14765  * Return value: the column the interactive search code searches in.
14766  */
14767 gint
14768 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
14769 {
14770   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
14771
14772   return (tree_view->priv->search_column);
14773 }
14774
14775 /**
14776  * gtk_tree_view_set_search_column:
14777  * @tree_view: A #GtkTreeView
14778  * @column: the column of the model to search in, or -1 to disable searching
14779  *
14780  * Sets @column as the column where the interactive search code should
14781  * search in for the current model.
14782  *
14783  * If the search column is set, users can use the "start-interactive-search"
14784  * key binding to bring up search popup. The enable-search property controls
14785  * whether simply typing text will also start an interactive search.
14786  *
14787  * Note that @column refers to a column of the current model. The search
14788  * column is reset to -1 when the model is changed.
14789  */
14790 void
14791 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
14792                                  gint         column)
14793 {
14794   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14795   g_return_if_fail (column >= -1);
14796
14797   if (tree_view->priv->search_column == column)
14798     return;
14799
14800   tree_view->priv->search_column = column;
14801   g_object_notify (G_OBJECT (tree_view), "search-column");
14802 }
14803
14804 /**
14805  * gtk_tree_view_get_search_equal_func: (skip)
14806  * @tree_view: A #GtkTreeView
14807  *
14808  * Returns the compare function currently in use.
14809  *
14810  * Return value: the currently used compare function for the search code.
14811  */
14812
14813 GtkTreeViewSearchEqualFunc
14814 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
14815 {
14816   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14817
14818   return tree_view->priv->search_equal_func;
14819 }
14820
14821 /**
14822  * gtk_tree_view_set_search_equal_func:
14823  * @tree_view: A #GtkTreeView
14824  * @search_equal_func: the compare function to use during the search
14825  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
14826  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
14827  *
14828  * Sets the compare function for the interactive search capabilities; note
14829  * that somewhat like strcmp() returning 0 for equality
14830  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
14831  **/
14832 void
14833 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14834                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14835                                      gpointer                    search_user_data,
14836                                      GDestroyNotify              search_destroy)
14837 {
14838   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14839   g_return_if_fail (search_equal_func != NULL);
14840
14841   if (tree_view->priv->search_destroy)
14842     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14843
14844   tree_view->priv->search_equal_func = search_equal_func;
14845   tree_view->priv->search_user_data = search_user_data;
14846   tree_view->priv->search_destroy = search_destroy;
14847   if (tree_view->priv->search_equal_func == NULL)
14848     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14849 }
14850
14851 /**
14852  * gtk_tree_view_get_search_entry:
14853  * @tree_view: A #GtkTreeView
14854  *
14855  * Returns the #GtkEntry which is currently in use as interactive search
14856  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14857  * will be returned.
14858  *
14859  * Return value: (transfer none): the entry currently in use as search entry.
14860  *
14861  * Since: 2.10
14862  */
14863 GtkEntry *
14864 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14865 {
14866   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14867
14868   if (tree_view->priv->search_custom_entry_set)
14869     return GTK_ENTRY (tree_view->priv->search_entry);
14870
14871   return NULL;
14872 }
14873
14874 /**
14875  * gtk_tree_view_set_search_entry:
14876  * @tree_view: A #GtkTreeView
14877  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
14878  *
14879  * Sets the entry which the interactive search code will use for this
14880  * @tree_view.  This is useful when you want to provide a search entry
14881  * in our interface at all time at a fixed position.  Passing %NULL for
14882  * @entry will make the interactive search code use the built-in popup
14883  * entry again.
14884  *
14885  * Since: 2.10
14886  */
14887 void
14888 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14889                                 GtkEntry    *entry)
14890 {
14891   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14892   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14893
14894   if (tree_view->priv->search_custom_entry_set)
14895     {
14896       if (tree_view->priv->search_entry_changed_id)
14897         {
14898           g_signal_handler_disconnect (tree_view->priv->search_entry,
14899                                        tree_view->priv->search_entry_changed_id);
14900           tree_view->priv->search_entry_changed_id = 0;
14901         }
14902       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14903                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14904                                             tree_view);
14905
14906       g_object_unref (tree_view->priv->search_entry);
14907     }
14908   else if (tree_view->priv->search_window)
14909     {
14910       gtk_widget_destroy (tree_view->priv->search_window);
14911
14912       tree_view->priv->search_window = NULL;
14913     }
14914
14915   if (entry)
14916     {
14917       tree_view->priv->search_entry = g_object_ref (entry);
14918       tree_view->priv->search_custom_entry_set = TRUE;
14919
14920       if (tree_view->priv->search_entry_changed_id == 0)
14921         {
14922           tree_view->priv->search_entry_changed_id =
14923             g_signal_connect (tree_view->priv->search_entry, "changed",
14924                               G_CALLBACK (gtk_tree_view_search_init),
14925                               tree_view);
14926         }
14927
14928         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14929                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14930                           tree_view);
14931
14932         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14933     }
14934   else
14935     {
14936       tree_view->priv->search_entry = NULL;
14937       tree_view->priv->search_custom_entry_set = FALSE;
14938     }
14939 }
14940
14941 /**
14942  * gtk_tree_view_set_search_position_func:
14943  * @tree_view: A #GtkTreeView
14944  * @func: (allow-none): the function to use to position the search dialog, or %NULL
14945  *    to use the default search position function
14946  * @data: (allow-none): user data to pass to @func, or %NULL
14947  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14948  *
14949  * Sets the function to use when positioning the search dialog.
14950  *
14951  * Since: 2.10
14952  **/
14953 void
14954 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
14955                                         GtkTreeViewSearchPositionFunc  func,
14956                                         gpointer                       user_data,
14957                                         GDestroyNotify                 destroy)
14958 {
14959   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14960
14961   if (tree_view->priv->search_position_destroy)
14962     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
14963
14964   tree_view->priv->search_position_func = func;
14965   tree_view->priv->search_position_user_data = user_data;
14966   tree_view->priv->search_position_destroy = destroy;
14967   if (tree_view->priv->search_position_func == NULL)
14968     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
14969 }
14970
14971 /**
14972  * gtk_tree_view_get_search_position_func: (skip)
14973  * @tree_view: A #GtkTreeView
14974  *
14975  * Returns the positioning function currently in use.
14976  *
14977  * Return value: the currently used function for positioning the search dialog.
14978  *
14979  * Since: 2.10
14980  */
14981 GtkTreeViewSearchPositionFunc
14982 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
14983 {
14984   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14985
14986   return tree_view->priv->search_position_func;
14987 }
14988
14989
14990 static void
14991 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
14992                                   GtkTreeView *tree_view,
14993                                   GdkDevice   *device)
14994 {
14995   if (tree_view->priv->disable_popdown)
14996     return;
14997
14998   if (tree_view->priv->search_entry_changed_id)
14999     {
15000       g_signal_handler_disconnect (tree_view->priv->search_entry,
15001                                    tree_view->priv->search_entry_changed_id);
15002       tree_view->priv->search_entry_changed_id = 0;
15003     }
15004   if (tree_view->priv->typeselect_flush_timeout)
15005     {
15006       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15007       tree_view->priv->typeselect_flush_timeout = 0;
15008     }
15009
15010   if (gtk_widget_get_visible (search_dialog))
15011     {
15012       /* send focus-in event */
15013       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
15014       gtk_widget_hide (search_dialog);
15015       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
15016       send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
15017     }
15018 }
15019
15020 static void
15021 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
15022                                     GtkWidget   *search_dialog,
15023                                     gpointer     user_data)
15024 {
15025   gint x, y;
15026   gint tree_x, tree_y;
15027   gint tree_width, tree_height;
15028   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
15029   GdkScreen *screen = gdk_window_get_screen (tree_window);
15030   GtkRequisition requisition;
15031   gint monitor_num;
15032   GdkRectangle monitor;
15033
15034   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
15035   gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
15036
15037   gtk_widget_realize (search_dialog);
15038
15039   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
15040   tree_width = gdk_window_get_width (tree_window);
15041   tree_height = gdk_window_get_height (tree_window);
15042   gtk_widget_get_preferred_size (search_dialog, &requisition, NULL);
15043
15044   if (tree_x + tree_width > gdk_screen_get_width (screen))
15045     x = gdk_screen_get_width (screen) - requisition.width;
15046   else if (tree_x + tree_width - requisition.width < 0)
15047     x = 0;
15048   else
15049     x = tree_x + tree_width - requisition.width;
15050
15051   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
15052     y = gdk_screen_get_height (screen) - requisition.height;
15053   else if (tree_y + tree_height < 0) /* isn't really possible ... */
15054     y = 0;
15055   else
15056     y = tree_y + tree_height;
15057
15058   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
15059 }
15060
15061 static void
15062 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
15063                                       GtkMenu  *menu,
15064                                       gpointer  data)
15065 {
15066   GtkTreeView *tree_view = (GtkTreeView *)data;
15067
15068   tree_view->priv->disable_popdown = 1;
15069   g_signal_connect (menu, "hide",
15070                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
15071 }
15072
15073 /* Because we're visible but offscreen, we just set a flag in the preedit
15074  * callback.
15075  */
15076 static void
15077 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
15078                                       GtkTreeView  *tree_view)
15079 {
15080   tree_view->priv->imcontext_changed = 1;
15081   if (tree_view->priv->typeselect_flush_timeout)
15082     {
15083       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15084       tree_view->priv->typeselect_flush_timeout =
15085         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15086                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15087                        tree_view);
15088     }
15089
15090 }
15091
15092 static void
15093 gtk_tree_view_search_activate (GtkEntry    *entry,
15094                                GtkTreeView *tree_view)
15095 {
15096   GtkTreePath *path;
15097
15098   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
15099                                     tree_view,
15100                                     gtk_get_current_event_device ());
15101
15102   /* If we have a row selected and it's the cursor row, we activate
15103    * the row XXX */
15104   if (tree_view->priv->cursor_node &&
15105       GTK_RBNODE_FLAG_SET (tree_view->priv->cursor_node, GTK_RBNODE_IS_SELECTED))
15106     {
15107       path = _gtk_tree_path_new_from_rbtree (tree_view->priv->cursor_tree,
15108                                              tree_view->priv->cursor_node);
15109
15110       gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
15111
15112       gtk_tree_path_free (path);
15113     }
15114 }
15115
15116 static gboolean
15117 gtk_tree_view_real_search_enable_popdown (gpointer data)
15118 {
15119   GtkTreeView *tree_view = (GtkTreeView *)data;
15120
15121   tree_view->priv->disable_popdown = 0;
15122
15123   return FALSE;
15124 }
15125
15126 static void
15127 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
15128                                      gpointer   data)
15129 {
15130   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
15131 }
15132
15133 static gboolean
15134 gtk_tree_view_search_delete_event (GtkWidget *widget,
15135                                    GdkEventAny *event,
15136                                    GtkTreeView *tree_view)
15137 {
15138   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15139
15140   gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
15141
15142   return TRUE;
15143 }
15144
15145 static gboolean
15146 gtk_tree_view_search_button_press_event (GtkWidget *widget,
15147                                          GdkEventButton *event,
15148                                          GtkTreeView *tree_view)
15149 {
15150   GdkDevice *keyb_device;
15151
15152   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15153
15154   keyb_device = gdk_device_get_associated_device (event->device);
15155   gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
15156
15157   if (event->window == tree_view->priv->bin_window)
15158     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
15159
15160   return TRUE;
15161 }
15162
15163 static gboolean
15164 gtk_tree_view_search_scroll_event (GtkWidget *widget,
15165                                    GdkEventScroll *event,
15166                                    GtkTreeView *tree_view)
15167 {
15168   gboolean retval = FALSE;
15169
15170   if (event->direction == GDK_SCROLL_UP)
15171     {
15172       gtk_tree_view_search_move (widget, tree_view, TRUE);
15173       retval = TRUE;
15174     }
15175   else if (event->direction == GDK_SCROLL_DOWN)
15176     {
15177       gtk_tree_view_search_move (widget, tree_view, FALSE);
15178       retval = TRUE;
15179     }
15180
15181   /* renew the flush timeout */
15182   if (retval && tree_view->priv->typeselect_flush_timeout
15183       && !tree_view->priv->search_custom_entry_set)
15184     {
15185       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15186       tree_view->priv->typeselect_flush_timeout =
15187         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15188                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15189                        tree_view);
15190     }
15191
15192   return retval;
15193 }
15194
15195 static gboolean
15196 gtk_tree_view_search_key_press_event (GtkWidget *widget,
15197                                       GdkEventKey *event,
15198                                       GtkTreeView *tree_view)
15199 {
15200   GdkModifierType default_accel;
15201   gboolean        retval = FALSE;
15202
15203   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
15204   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15205
15206   /* close window and cancel the search */
15207   if (!tree_view->priv->search_custom_entry_set
15208       && (event->keyval == GDK_KEY_Escape ||
15209           event->keyval == GDK_KEY_Tab ||
15210             event->keyval == GDK_KEY_KP_Tab ||
15211             event->keyval == GDK_KEY_ISO_Left_Tab))
15212     {
15213       gtk_tree_view_search_dialog_hide (widget, tree_view,
15214                                         gdk_event_get_device ((GdkEvent *) event));
15215       return TRUE;
15216     }
15217
15218   default_accel = gtk_widget_get_modifier_mask (widget,
15219                                                 GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
15220
15221   /* select previous matching iter */
15222   if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
15223     {
15224       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15225         gtk_widget_error_bell (widget);
15226
15227       retval = TRUE;
15228     }
15229
15230   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == (default_accel | GDK_SHIFT_MASK))
15231       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15232     {
15233       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
15234         gtk_widget_error_bell (widget);
15235
15236       retval = TRUE;
15237     }
15238
15239   /* select next matching iter */
15240   if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
15241     {
15242       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15243         gtk_widget_error_bell (widget);
15244
15245       retval = TRUE;
15246     }
15247
15248   if (((event->state & (default_accel | GDK_SHIFT_MASK)) == default_accel)
15249       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
15250     {
15251       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
15252         gtk_widget_error_bell (widget);
15253
15254       retval = TRUE;
15255     }
15256
15257   /* renew the flush timeout */
15258   if (retval && tree_view->priv->typeselect_flush_timeout
15259       && !tree_view->priv->search_custom_entry_set)
15260     {
15261       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15262       tree_view->priv->typeselect_flush_timeout =
15263         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15264                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15265                        tree_view);
15266     }
15267
15268   return retval;
15269 }
15270
15271 /*  this function returns FALSE if there is a search string but
15272  *  nothing was found, and TRUE otherwise.
15273  */
15274 static gboolean
15275 gtk_tree_view_search_move (GtkWidget   *window,
15276                            GtkTreeView *tree_view,
15277                            gboolean     up)
15278 {
15279   gboolean ret;
15280   gint len;
15281   gint count = 0;
15282   const gchar *text;
15283   GtkTreeIter iter;
15284   GtkTreeModel *model;
15285   GtkTreeSelection *selection;
15286
15287   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
15288
15289   g_return_val_if_fail (text != NULL, FALSE);
15290
15291   len = strlen (text);
15292
15293   if (up && tree_view->priv->selected_iter == 1)
15294     return strlen (text) < 1;
15295
15296   len = strlen (text);
15297
15298   if (len < 1)
15299     return TRUE;
15300
15301   model = gtk_tree_view_get_model (tree_view);
15302   selection = gtk_tree_view_get_selection (tree_view);
15303
15304   /* search */
15305   gtk_tree_selection_unselect_all (selection);
15306   if (!gtk_tree_model_get_iter_first (model, &iter))
15307     return TRUE;
15308
15309   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
15310                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
15311
15312   if (ret)
15313     {
15314       /* found */
15315       tree_view->priv->selected_iter += up?(-1):(1);
15316       return TRUE;
15317     }
15318   else
15319     {
15320       /* return to old iter */
15321       count = 0;
15322       gtk_tree_model_get_iter_first (model, &iter);
15323       gtk_tree_view_search_iter (model, selection,
15324                                  &iter, text,
15325                                  &count, tree_view->priv->selected_iter);
15326       return FALSE;
15327     }
15328 }
15329
15330 static gboolean
15331 gtk_tree_view_search_equal_func (GtkTreeModel *model,
15332                                  gint          column,
15333                                  const gchar  *key,
15334                                  GtkTreeIter  *iter,
15335                                  gpointer      search_data)
15336 {
15337   gboolean retval = TRUE;
15338   const gchar *str;
15339   gchar *normalized_string;
15340   gchar *normalized_key;
15341   gchar *case_normalized_string = NULL;
15342   gchar *case_normalized_key = NULL;
15343   GValue value = G_VALUE_INIT;
15344   GValue transformed = G_VALUE_INIT;
15345
15346   gtk_tree_model_get_value (model, iter, column, &value);
15347
15348   g_value_init (&transformed, G_TYPE_STRING);
15349
15350   if (!g_value_transform (&value, &transformed))
15351     {
15352       g_value_unset (&value);
15353       return TRUE;
15354     }
15355
15356   g_value_unset (&value);
15357
15358   str = g_value_get_string (&transformed);
15359   if (!str)
15360     {
15361       g_value_unset (&transformed);
15362       return TRUE;
15363     }
15364
15365   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
15366   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
15367
15368   if (normalized_string && normalized_key)
15369     {
15370       case_normalized_string = g_utf8_casefold (normalized_string, -1);
15371       case_normalized_key = g_utf8_casefold (normalized_key, -1);
15372
15373       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
15374         retval = FALSE;
15375     }
15376
15377   g_value_unset (&transformed);
15378   g_free (normalized_key);
15379   g_free (normalized_string);
15380   g_free (case_normalized_key);
15381   g_free (case_normalized_string);
15382
15383   return retval;
15384 }
15385
15386 static gboolean
15387 gtk_tree_view_search_iter (GtkTreeModel     *model,
15388                            GtkTreeSelection *selection,
15389                            GtkTreeIter      *iter,
15390                            const gchar      *text,
15391                            gint             *count,
15392                            gint              n)
15393 {
15394   GtkRBTree *tree = NULL;
15395   GtkRBNode *node = NULL;
15396   GtkTreePath *path;
15397
15398   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
15399
15400   path = gtk_tree_model_get_path (model, iter);
15401   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
15402
15403   do
15404     {
15405       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
15406         {
15407           (*count)++;
15408           if (*count == n)
15409             {
15410               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
15411                                             TRUE, 0.5, 0.0);
15412               gtk_tree_selection_select_iter (selection, iter);
15413               gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15414
15415               if (path)
15416                 gtk_tree_path_free (path);
15417
15418               return TRUE;
15419             }
15420         }
15421
15422       if (node->children)
15423         {
15424           gboolean has_child;
15425           GtkTreeIter tmp;
15426
15427           tree = node->children;
15428           node = _gtk_rbtree_first (tree);
15429
15430           tmp = *iter;
15431           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
15432           gtk_tree_path_down (path);
15433
15434           /* sanity check */
15435           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
15436         }
15437       else
15438         {
15439           gboolean done = FALSE;
15440
15441           do
15442             {
15443               node = _gtk_rbtree_next (tree, node);
15444
15445               if (node)
15446                 {
15447                   gboolean has_next;
15448
15449                   has_next = gtk_tree_model_iter_next (model, iter);
15450
15451                   done = TRUE;
15452                   gtk_tree_path_next (path);
15453
15454                   /* sanity check */
15455                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
15456                 }
15457               else
15458                 {
15459                   gboolean has_parent;
15460                   GtkTreeIter tmp_iter = *iter;
15461
15462                   node = tree->parent_node;
15463                   tree = tree->parent_tree;
15464
15465                   if (!tree)
15466                     {
15467                       if (path)
15468                         gtk_tree_path_free (path);
15469
15470                       /* we've run out of tree, done with this func */
15471                       return FALSE;
15472                     }
15473
15474                   has_parent = gtk_tree_model_iter_parent (model,
15475                                                            iter,
15476                                                            &tmp_iter);
15477                   gtk_tree_path_up (path);
15478
15479                   /* sanity check */
15480                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
15481                 }
15482             }
15483           while (!done);
15484         }
15485     }
15486   while (1);
15487
15488   return FALSE;
15489 }
15490
15491 static void
15492 gtk_tree_view_search_init (GtkWidget   *entry,
15493                            GtkTreeView *tree_view)
15494 {
15495   gint ret;
15496   gint count = 0;
15497   const gchar *text;
15498   GtkTreeIter iter;
15499   GtkTreeModel *model;
15500   GtkTreeSelection *selection;
15501
15502   g_return_if_fail (GTK_IS_ENTRY (entry));
15503   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15504
15505   text = gtk_entry_get_text (GTK_ENTRY (entry));
15506
15507   model = gtk_tree_view_get_model (tree_view);
15508   selection = gtk_tree_view_get_selection (tree_view);
15509
15510   /* search */
15511   gtk_tree_selection_unselect_all (selection);
15512   if (tree_view->priv->typeselect_flush_timeout
15513       && !tree_view->priv->search_custom_entry_set)
15514     {
15515       g_source_remove (tree_view->priv->typeselect_flush_timeout);
15516       tree_view->priv->typeselect_flush_timeout =
15517         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
15518                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
15519                        tree_view);
15520     }
15521
15522   if (*text == '\0')
15523     return;
15524
15525   if (!gtk_tree_model_get_iter_first (model, &iter))
15526     return;
15527
15528   ret = gtk_tree_view_search_iter (model, selection,
15529                                    &iter, text,
15530                                    &count, 1);
15531
15532   if (ret)
15533     tree_view->priv->selected_iter = 1;
15534 }
15535
15536 void
15537 _gtk_tree_view_remove_editable (GtkTreeView       *tree_view,
15538                                 GtkTreeViewColumn *column,
15539                                 GtkCellEditable   *cell_editable)
15540 {
15541   if (tree_view->priv->edited_column == NULL)
15542     return;
15543
15544   g_return_if_fail (column == tree_view->priv->edited_column);
15545
15546   tree_view->priv->edited_column = NULL;
15547
15548   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
15549     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
15550
15551   gtk_container_remove (GTK_CONTAINER (tree_view),
15552                         GTK_WIDGET (cell_editable));
15553
15554   /* FIXME should only redraw a single node */
15555   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15556 }
15557
15558 static gboolean
15559 gtk_tree_view_start_editing (GtkTreeView *tree_view,
15560                              GtkTreePath *cursor_path,
15561                              gboolean     edit_only)
15562 {
15563   GtkTreeIter iter;
15564   GdkRectangle cell_area;
15565   GtkTreeViewColumn *focus_column;
15566   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
15567   gint retval = FALSE;
15568   GtkRBTree *cursor_tree;
15569   GtkRBNode *cursor_node;
15570
15571   g_assert (tree_view->priv->focus_column);
15572   focus_column = tree_view->priv->focus_column;
15573
15574   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
15575     return FALSE;
15576
15577   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
15578       cursor_node == NULL)
15579     return FALSE;
15580
15581   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
15582
15583   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
15584
15585   gtk_tree_view_column_cell_set_cell_data (focus_column,
15586                                            tree_view->priv->model,
15587                                            &iter,
15588                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
15589                                            cursor_node->children ? TRUE : FALSE);
15590   gtk_tree_view_get_cell_area (tree_view,
15591                                cursor_path,
15592                                focus_column,
15593                                &cell_area);
15594
15595   if (gtk_cell_area_activate (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (focus_column)),
15596                               _gtk_tree_view_column_get_context (focus_column),
15597                               GTK_WIDGET (tree_view),
15598                               &cell_area,
15599                               flags, edit_only))
15600     retval = TRUE;
15601
15602   return retval;
15603 }
15604
15605 void
15606 _gtk_tree_view_add_editable (GtkTreeView       *tree_view,
15607                              GtkTreeViewColumn *column,
15608                              GtkTreePath       *path,
15609                              GtkCellEditable   *cell_editable,
15610                              GdkRectangle      *cell_area)
15611 {
15612   gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
15613   GtkRequisition requisition;
15614
15615   tree_view->priv->edited_column = column;
15616
15617   gtk_tree_view_real_set_cursor (tree_view, path, CLAMP_NODE);
15618   cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
15619
15620   gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
15621                                  &requisition, NULL);
15622
15623   tree_view->priv->draw_keyfocus = TRUE;
15624
15625   if (requisition.height < cell_area->height)
15626     {
15627       gint diff = cell_area->height - requisition.height;
15628       gtk_tree_view_put (tree_view,
15629                          GTK_WIDGET (cell_editable),
15630                          cell_area->x, cell_area->y + diff/2,
15631                          cell_area->width, requisition.height);
15632     }
15633   else
15634     {
15635       gtk_tree_view_put (tree_view,
15636                          GTK_WIDGET (cell_editable),
15637                          cell_area->x, cell_area->y,
15638                          cell_area->width, cell_area->height);
15639     }
15640 }
15641
15642 static void
15643 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
15644                             gboolean     cancel_editing)
15645 {
15646   GtkTreeViewColumn *column;
15647
15648   if (tree_view->priv->edited_column == NULL)
15649     return;
15650
15651   /*
15652    * This is very evil. We need to do this, because
15653    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
15654    * later on. If gtk_tree_view_row_changed notices
15655    * tree_view->priv->edited_column != NULL, it'll call
15656    * gtk_tree_view_stop_editing again. Bad things will happen then.
15657    *
15658    * Please read that again if you intend to modify anything here.
15659    */
15660
15661   column = tree_view->priv->edited_column;
15662   gtk_cell_area_stop_editing (gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)), cancel_editing);
15663   tree_view->priv->edited_column = NULL;
15664 }
15665
15666
15667 /**
15668  * gtk_tree_view_set_hover_selection:
15669  * @tree_view: a #GtkTreeView
15670  * @hover: %TRUE to enable hover selection mode
15671  *
15672  * Enables or disables the hover selection mode of @tree_view.
15673  * Hover selection makes the selected row follow the pointer.
15674  * Currently, this works only for the selection modes
15675  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
15676  *
15677  * Since: 2.6
15678  **/
15679 void
15680 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
15681                                    gboolean     hover)
15682 {
15683   hover = hover != FALSE;
15684
15685   if (hover != tree_view->priv->hover_selection)
15686     {
15687       tree_view->priv->hover_selection = hover;
15688
15689       g_object_notify (G_OBJECT (tree_view), "hover-selection");
15690     }
15691 }
15692
15693 /**
15694  * gtk_tree_view_get_hover_selection:
15695  * @tree_view: a #GtkTreeView
15696  *
15697  * Returns whether hover selection mode is turned on for @tree_view.
15698  *
15699  * Return value: %TRUE if @tree_view is in hover selection mode
15700  *
15701  * Since: 2.6
15702  **/
15703 gboolean
15704 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
15705 {
15706   return tree_view->priv->hover_selection;
15707 }
15708
15709 /**
15710  * gtk_tree_view_set_hover_expand:
15711  * @tree_view: a #GtkTreeView
15712  * @expand: %TRUE to enable hover selection mode
15713  *
15714  * Enables or disables the hover expansion mode of @tree_view.
15715  * Hover expansion makes rows expand or collapse if the pointer
15716  * moves over them.
15717  *
15718  * Since: 2.6
15719  **/
15720 void
15721 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
15722                                 gboolean     expand)
15723 {
15724   expand = expand != FALSE;
15725
15726   if (expand != tree_view->priv->hover_expand)
15727     {
15728       tree_view->priv->hover_expand = expand;
15729
15730       g_object_notify (G_OBJECT (tree_view), "hover-expand");
15731     }
15732 }
15733
15734 /**
15735  * gtk_tree_view_get_hover_expand:
15736  * @tree_view: a #GtkTreeView
15737  *
15738  * Returns whether hover expansion mode is turned on for @tree_view.
15739  *
15740  * Return value: %TRUE if @tree_view is in hover expansion mode
15741  *
15742  * Since: 2.6
15743  **/
15744 gboolean
15745 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
15746 {
15747   return tree_view->priv->hover_expand;
15748 }
15749
15750 /**
15751  * gtk_tree_view_set_rubber_banding:
15752  * @tree_view: a #GtkTreeView
15753  * @enable: %TRUE to enable rubber banding
15754  *
15755  * Enables or disables rubber banding in @tree_view.  If the selection mode
15756  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
15757  * multiple rows by dragging the mouse.
15758  *
15759  * Since: 2.10
15760  **/
15761 void
15762 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
15763                                   gboolean     enable)
15764 {
15765   enable = enable != FALSE;
15766
15767   if (enable != tree_view->priv->rubber_banding_enable)
15768     {
15769       tree_view->priv->rubber_banding_enable = enable;
15770
15771       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
15772     }
15773 }
15774
15775 /**
15776  * gtk_tree_view_get_rubber_banding:
15777  * @tree_view: a #GtkTreeView
15778  *
15779  * Returns whether rubber banding is turned on for @tree_view.  If the
15780  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15781  * user to select multiple rows by dragging the mouse.
15782  *
15783  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15784  *
15785  * Since: 2.10
15786  **/
15787 gboolean
15788 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15789 {
15790   return tree_view->priv->rubber_banding_enable;
15791 }
15792
15793 /**
15794  * gtk_tree_view_is_rubber_banding_active:
15795  * @tree_view: a #GtkTreeView
15796  *
15797  * Returns whether a rubber banding operation is currently being done
15798  * in @tree_view.
15799  *
15800  * Return value: %TRUE if a rubber banding operation is currently being
15801  * done in @tree_view.
15802  *
15803  * Since: 2.12
15804  **/
15805 gboolean
15806 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15807 {
15808   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15809
15810   if (tree_view->priv->rubber_banding_enable
15811       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15812     return TRUE;
15813
15814   return FALSE;
15815 }
15816
15817 /**
15818  * gtk_tree_view_get_row_separator_func: (skip)
15819  * @tree_view: a #GtkTreeView
15820  *
15821  * Returns the current row separator function.
15822  *
15823  * Return value: the current row separator function.
15824  *
15825  * Since: 2.6
15826  **/
15827 GtkTreeViewRowSeparatorFunc
15828 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15829 {
15830   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15831
15832   return tree_view->priv->row_separator_func;
15833 }
15834
15835 /**
15836  * gtk_tree_view_set_row_separator_func:
15837  * @tree_view: a #GtkTreeView
15838  * @func: (allow-none): a #GtkTreeViewRowSeparatorFunc
15839  * @data: (allow-none): user data to pass to @func, or %NULL
15840  * @destroy: (allow-none): destroy notifier for @data, or %NULL
15841  *
15842  * Sets the row separator function, which is used to determine
15843  * whether a row should be drawn as a separator. If the row separator
15844  * function is %NULL, no separators are drawn. This is the default value.
15845  *
15846  * Since: 2.6
15847  **/
15848 void
15849 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15850                                       GtkTreeViewRowSeparatorFunc  func,
15851                                       gpointer                     data,
15852                                       GDestroyNotify               destroy)
15853 {
15854   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15855
15856   if (tree_view->priv->row_separator_destroy)
15857     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15858
15859   tree_view->priv->row_separator_func = func;
15860   tree_view->priv->row_separator_data = data;
15861   tree_view->priv->row_separator_destroy = destroy;
15862
15863   /* Have the tree recalculate heights */
15864   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15865   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15866 }
15867
15868
15869 static void
15870 gtk_tree_view_grab_notify (GtkWidget *widget,
15871                            gboolean   was_grabbed)
15872 {
15873   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15874
15875   tree_view->priv->in_grab = !was_grabbed;
15876
15877   if (!was_grabbed)
15878     {
15879       tree_view->priv->pressed_button = -1;
15880
15881       if (tree_view->priv->rubber_band_status)
15882         gtk_tree_view_stop_rubber_band (tree_view);
15883     }
15884 }
15885
15886 static void
15887 gtk_tree_view_state_flags_changed (GtkWidget     *widget,
15888                                    GtkStateFlags  previous_state)
15889 {
15890   if (gtk_widget_get_realized (widget))
15891     gtk_tree_view_ensure_background (GTK_TREE_VIEW (widget));
15892
15893   gtk_widget_queue_draw (widget);
15894 }
15895
15896 /**
15897  * gtk_tree_view_get_grid_lines:
15898  * @tree_view: a #GtkTreeView
15899  *
15900  * Returns which grid lines are enabled in @tree_view.
15901  *
15902  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15903  * are enabled.
15904  *
15905  * Since: 2.10
15906  */
15907 GtkTreeViewGridLines
15908 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15909 {
15910   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15911
15912   return tree_view->priv->grid_lines;
15913 }
15914
15915 /**
15916  * gtk_tree_view_set_grid_lines:
15917  * @tree_view: a #GtkTreeView
15918  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15919  * enable.
15920  *
15921  * Sets which grid lines to draw in @tree_view.
15922  *
15923  * Since: 2.10
15924  */
15925 void
15926 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15927                               GtkTreeViewGridLines   grid_lines)
15928 {
15929   GtkTreeViewPrivate *priv;
15930   GtkWidget *widget;
15931   GtkTreeViewGridLines old_grid_lines;
15932
15933   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15934
15935   priv = tree_view->priv;
15936   widget = GTK_WIDGET (tree_view);
15937
15938   old_grid_lines = priv->grid_lines;
15939   priv->grid_lines = grid_lines;
15940
15941   if (gtk_widget_get_realized (widget))
15942     {
15943       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15944           priv->grid_line_width)
15945         {
15946           priv->grid_line_width = 0;
15947         }
15948
15949       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15950           !priv->grid_line_width)
15951         {
15952           gint8 *dash_list;
15953
15954           gtk_widget_style_get (widget,
15955                                 "grid-line-width", &priv->grid_line_width,
15956                                 "grid-line-pattern", (gchar *)&dash_list,
15957                                 NULL);
15958
15959           if (dash_list)
15960             {
15961               priv->grid_line_dashes[0] = dash_list[0];
15962               if (dash_list[0])
15963                 priv->grid_line_dashes[1] = dash_list[1];
15964
15965               g_free (dash_list);
15966             }
15967           else
15968             {
15969               priv->grid_line_dashes[0] = 1;
15970               priv->grid_line_dashes[1] = 1;
15971             }
15972         }
15973     }
15974
15975   if (old_grid_lines != grid_lines)
15976     {
15977       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15978
15979       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
15980     }
15981 }
15982
15983 /**
15984  * gtk_tree_view_get_enable_tree_lines:
15985  * @tree_view: a #GtkTreeView.
15986  *
15987  * Returns whether or not tree lines are drawn in @tree_view.
15988  *
15989  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
15990  * otherwise.
15991  *
15992  * Since: 2.10
15993  */
15994 gboolean
15995 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
15996 {
15997   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15998
15999   return tree_view->priv->tree_lines_enabled;
16000 }
16001
16002 /**
16003  * gtk_tree_view_set_enable_tree_lines:
16004  * @tree_view: a #GtkTreeView
16005  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
16006  *
16007  * Sets whether to draw lines interconnecting the expanders in @tree_view.
16008  * This does not have any visible effects for lists.
16009  *
16010  * Since: 2.10
16011  */
16012 void
16013 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
16014                                      gboolean     enabled)
16015 {
16016   GtkTreeViewPrivate *priv;
16017   GtkWidget *widget;
16018   gboolean was_enabled;
16019
16020   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16021
16022   enabled = enabled != FALSE;
16023
16024   priv = tree_view->priv;
16025   widget = GTK_WIDGET (tree_view);
16026
16027   was_enabled = priv->tree_lines_enabled;
16028
16029   priv->tree_lines_enabled = enabled;
16030
16031   if (gtk_widget_get_realized (widget))
16032     {
16033       if (!enabled && priv->tree_line_width)
16034         {
16035           priv->tree_line_width = 0;
16036         }
16037
16038       if (enabled && !priv->tree_line_width)
16039         {
16040           gint8 *dash_list;
16041           gtk_widget_style_get (widget,
16042                                 "tree-line-width", &priv->tree_line_width,
16043                                 "tree-line-pattern", (gchar *)&dash_list,
16044                                 NULL);
16045
16046           if (dash_list)
16047             {
16048               priv->tree_line_dashes[0] = dash_list[0];
16049               if (dash_list[0])
16050                 priv->tree_line_dashes[1] = dash_list[1];
16051
16052               g_free (dash_list);
16053             }
16054           else
16055             {
16056               priv->tree_line_dashes[0] = 1;
16057               priv->tree_line_dashes[1] = 1;
16058             }
16059         }
16060     }
16061
16062   if (was_enabled != enabled)
16063     {
16064       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16065
16066       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
16067     }
16068 }
16069
16070
16071 /**
16072  * gtk_tree_view_set_show_expanders:
16073  * @tree_view: a #GtkTreeView
16074  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
16075  *
16076  * Sets whether to draw and enable expanders and indent child rows in
16077  * @tree_view.  When disabled there will be no expanders visible in trees
16078  * and there will be no way to expand and collapse rows by default.  Also
16079  * note that hiding the expanders will disable the default indentation.  You
16080  * can set a custom indentation in this case using
16081  * gtk_tree_view_set_level_indentation().
16082  * This does not have any visible effects for lists.
16083  *
16084  * Since: 2.12
16085  */
16086 void
16087 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
16088                                   gboolean     enabled)
16089 {
16090   gboolean was_enabled;
16091
16092   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16093
16094   enabled = enabled != FALSE;
16095   was_enabled = tree_view->priv->show_expanders;
16096
16097   tree_view->priv->show_expanders = enabled == TRUE;
16098
16099   if (enabled != was_enabled)
16100     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16101 }
16102
16103 /**
16104  * gtk_tree_view_get_show_expanders:
16105  * @tree_view: a #GtkTreeView.
16106  *
16107  * Returns whether or not expanders are drawn in @tree_view.
16108  *
16109  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
16110  * otherwise.
16111  *
16112  * Since: 2.12
16113  */
16114 gboolean
16115 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
16116 {
16117   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16118
16119   return tree_view->priv->show_expanders;
16120 }
16121
16122 /**
16123  * gtk_tree_view_set_level_indentation:
16124  * @tree_view: a #GtkTreeView
16125  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
16126  *
16127  * Sets the amount of extra indentation for child levels to use in @tree_view
16128  * in addition to the default indentation.  The value should be specified in
16129  * pixels, a value of 0 disables this feature and in this case only the default
16130  * indentation will be used.
16131  * This does not have any visible effects for lists.
16132  *
16133  * Since: 2.12
16134  */
16135 void
16136 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
16137                                      gint         indentation)
16138 {
16139   tree_view->priv->level_indentation = indentation;
16140
16141   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
16142 }
16143
16144 /**
16145  * gtk_tree_view_get_level_indentation:
16146  * @tree_view: a #GtkTreeView.
16147  *
16148  * Returns the amount, in pixels, of extra indentation for child levels
16149  * in @tree_view.
16150  *
16151  * Return value: the amount of extra indentation for child levels in
16152  * @tree_view.  A return value of 0 means that this feature is disabled.
16153  *
16154  * Since: 2.12
16155  */
16156 gint
16157 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
16158 {
16159   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16160
16161   return tree_view->priv->level_indentation;
16162 }
16163
16164 /**
16165  * gtk_tree_view_set_tooltip_row:
16166  * @tree_view: a #GtkTreeView
16167  * @tooltip: a #GtkTooltip
16168  * @path: a #GtkTreePath
16169  *
16170  * Sets the tip area of @tooltip to be the area covered by the row at @path.
16171  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16172  * See also gtk_tooltip_set_tip_area().
16173  *
16174  * Since: 2.12
16175  */
16176 void
16177 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
16178                                GtkTooltip  *tooltip,
16179                                GtkTreePath *path)
16180 {
16181   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16182   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16183
16184   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
16185 }
16186
16187 /**
16188  * gtk_tree_view_set_tooltip_cell:
16189  * @tree_view: a #GtkTreeView
16190  * @tooltip: a #GtkTooltip
16191  * @path: (allow-none): a #GtkTreePath or %NULL
16192  * @column: (allow-none): a #GtkTreeViewColumn or %NULL
16193  * @cell: (allow-none): a #GtkCellRenderer or %NULL
16194  *
16195  * Sets the tip area of @tooltip to the area @path, @column and @cell have
16196  * in common.  For example if @path is %NULL and @column is set, the tip
16197  * area will be set to the full area covered by @column.  See also
16198  * gtk_tooltip_set_tip_area().
16199  *
16200  * Note that if @path is not specified and @cell is set and part of a column
16201  * containing the expander, the tooltip might not show and hide at the correct
16202  * position.  In such cases @path must be set to the current node under the
16203  * mouse cursor for this function to operate correctly.
16204  *
16205  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
16206  *
16207  * Since: 2.12
16208  */
16209 void
16210 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
16211                                 GtkTooltip        *tooltip,
16212                                 GtkTreePath       *path,
16213                                 GtkTreeViewColumn *column,
16214                                 GtkCellRenderer   *cell)
16215 {
16216   GtkAllocation allocation;
16217   GdkRectangle rect;
16218
16219   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16220   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
16221   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
16222   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
16223
16224   /* Determine x values. */
16225   if (column && cell)
16226     {
16227       GdkRectangle tmp;
16228       gint start, width;
16229
16230       /* We always pass in path here, whether it is NULL or not.
16231        * For cells in expander columns path must be specified so that
16232        * we can correctly account for the indentation.  This also means
16233        * that the tooltip is constrained vertically by the "Determine y
16234        * values" code below; this is not a real problem since cells actually
16235        * don't stretch vertically in constrast to columns.
16236        */
16237       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
16238       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
16239
16240       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16241                                                          tmp.x + start, 0,
16242                                                          &rect.x, NULL);
16243       rect.width = width;
16244     }
16245   else if (column)
16246     {
16247       GdkRectangle tmp;
16248
16249       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
16250       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16251                                                          tmp.x, 0,
16252                                                          &rect.x, NULL);
16253       rect.width = tmp.width;
16254     }
16255   else
16256     {
16257       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
16258       rect.x = 0;
16259       rect.width = allocation.width;
16260     }
16261
16262   /* Determine y values. */
16263   if (path)
16264     {
16265       GdkRectangle tmp;
16266
16267       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
16268       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
16269                                                          0, tmp.y,
16270                                                          NULL, &rect.y);
16271       rect.height = tmp.height;
16272     }
16273   else
16274     {
16275       rect.y = 0;
16276       rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
16277     }
16278
16279   gtk_tooltip_set_tip_area (tooltip, &rect);
16280 }
16281
16282 /**
16283  * gtk_tree_view_get_tooltip_context:
16284  * @tree_view: a #GtkTreeView
16285  * @x: (inout): the x coordinate (relative to widget coordinates)
16286  * @y: (inout): the y coordinate (relative to widget coordinates)
16287  * @keyboard_tip: whether this is a keyboard tooltip or not
16288  * @model: (out) (allow-none) (transfer none): a pointer to receive a
16289  *         #GtkTreeModel or %NULL
16290  * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
16291  * @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
16292  *
16293  * This function is supposed to be used in a #GtkWidget::query-tooltip
16294  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
16295  * which are received in the signal handler, should be passed to this
16296  * function without modification.
16297  *
16298  * The return value indicates whether there is a tree view row at the given
16299  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
16300  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
16301  * @model, @path and @iter which have been provided will be set to point to
16302  * that row and the corresponding model.  @x and @y will always be converted
16303  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
16304  *
16305  * Return value: whether or not the given tooltip context points to a row.
16306  *
16307  * Since: 2.12
16308  */
16309 gboolean
16310 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
16311                                    gint          *x,
16312                                    gint          *y,
16313                                    gboolean       keyboard_tip,
16314                                    GtkTreeModel **model,
16315                                    GtkTreePath  **path,
16316                                    GtkTreeIter   *iter)
16317 {
16318   GtkTreePath *tmppath = NULL;
16319
16320   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
16321   g_return_val_if_fail (x != NULL, FALSE);
16322   g_return_val_if_fail (y != NULL, FALSE);
16323
16324   if (keyboard_tip)
16325     {
16326       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
16327
16328       if (!tmppath)
16329         return FALSE;
16330     }
16331   else
16332     {
16333       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
16334                                                          x, y);
16335
16336       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
16337                                           &tmppath, NULL, NULL, NULL))
16338         return FALSE;
16339     }
16340
16341   if (model)
16342     *model = gtk_tree_view_get_model (tree_view);
16343
16344   if (iter)
16345     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
16346                              iter, tmppath);
16347
16348   if (path)
16349     *path = tmppath;
16350   else
16351     gtk_tree_path_free (tmppath);
16352
16353   return TRUE;
16354 }
16355
16356 static gboolean
16357 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
16358                                     gint        x,
16359                                     gint        y,
16360                                     gboolean    keyboard_tip,
16361                                     GtkTooltip *tooltip,
16362                                     gpointer    data)
16363 {
16364   GValue value = G_VALUE_INIT;
16365   GValue transformed = G_VALUE_INIT;
16366   GtkTreeIter iter;
16367   GtkTreePath *path;
16368   GtkTreeModel *model;
16369   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
16370
16371   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
16372                                           &x, &y,
16373                                           keyboard_tip,
16374                                           &model, &path, &iter))
16375     return FALSE;
16376
16377   gtk_tree_model_get_value (model, &iter,
16378                             tree_view->priv->tooltip_column, &value);
16379
16380   g_value_init (&transformed, G_TYPE_STRING);
16381
16382   if (!g_value_transform (&value, &transformed))
16383     {
16384       g_value_unset (&value);
16385       gtk_tree_path_free (path);
16386
16387       return FALSE;
16388     }
16389
16390   g_value_unset (&value);
16391
16392   if (!g_value_get_string (&transformed))
16393     {
16394       g_value_unset (&transformed);
16395       gtk_tree_path_free (path);
16396
16397       return FALSE;
16398     }
16399
16400   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
16401   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
16402
16403   gtk_tree_path_free (path);
16404   g_value_unset (&transformed);
16405
16406   return TRUE;
16407 }
16408
16409 /**
16410  * gtk_tree_view_set_tooltip_column:
16411  * @tree_view: a #GtkTreeView
16412  * @column: an integer, which is a valid column number for @tree_view's model
16413  *
16414  * If you only plan to have simple (text-only) tooltips on full rows, you
16415  * can use this function to have #GtkTreeView handle these automatically
16416  * for you. @column should be set to the column in @tree_view's model
16417  * containing the tooltip texts, or -1 to disable this feature.
16418  *
16419  * When enabled, #GtkWidget:has-tooltip will be set to %TRUE and
16420  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
16421  *
16422  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
16423  * so &amp;, &lt;, etc have to be escaped in the text.
16424  *
16425  * Since: 2.12
16426  */
16427 void
16428 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
16429                                   gint         column)
16430 {
16431   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
16432
16433   if (column == tree_view->priv->tooltip_column)
16434     return;
16435
16436   if (column == -1)
16437     {
16438       g_signal_handlers_disconnect_by_func (tree_view,
16439                                             gtk_tree_view_set_tooltip_query_cb,
16440                                             NULL);
16441       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
16442     }
16443   else
16444     {
16445       if (tree_view->priv->tooltip_column == -1)
16446         {
16447           g_signal_connect (tree_view, "query-tooltip",
16448                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
16449           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
16450         }
16451     }
16452
16453   tree_view->priv->tooltip_column = column;
16454   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
16455 }
16456
16457 /**
16458  * gtk_tree_view_get_tooltip_column:
16459  * @tree_view: a #GtkTreeView
16460  *
16461  * Returns the column of @tree_view's model which is being used for
16462  * displaying tooltips on @tree_view's rows.
16463  *
16464  * Return value: the index of the tooltip column that is currently being
16465  * used, or -1 if this is disabled.
16466  *
16467  * Since: 2.12
16468  */
16469 gint
16470 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
16471 {
16472   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
16473
16474   return tree_view->priv->tooltip_column;
16475 }